agentleFS
base58edbase58ed/claude_code_files/skills/grok-skill/SKILL.md

grok

Skill1 starsChanged 3 months agoMITView on GitHub

Load for "teach me", "explain", "help me understand", "grok", "why does", "how does X work", or any request to deeply learn a concept — math, physics, philosophy, CS, economics, or any intellectual domain.

11 other projects use a version of this.

Adopted by

Most recently taken up by

The file

Show its rules and text

We split this skill into the rules it gives an agent

21 rules. 0 are common, 21 are distinctive, and 0 are very specific to this project.

  • 0

    Common

    Most of the 4 edited versions we read keep these.

  • 21

    Distinctive

    This author's own choices. Worth a look.

  • 0

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Let the learner USE the model: before revealing its limits

    line 67
  2. Distinctive:

    Never apologize for the simple model.

    line 69
  3. Distinctive:

    Run it on a case where it works

    line 164
  4. Distinctive:

    Run it on a case where it breaks

    line 165
  5. Distinctive:

    Never start with the definition.

    line 178
  6. Distinctive:

    Use LaTeX in markdown artifacts: $\binom{n}{k}$, $\sum_{i=1}^{n}$, $\lim_{x \to 0}$ (plain notation in terminal replies)

    line 205
  7. Distinctive:

    Always compute before abstracting

    line 206
  8. Distinctive:

    Ask "what if?" at boundaries: $n = 0$, $n = 1$, $n \to \infty$

    line 207
  9. Distinctive:

    Never start with the philosopher's system.

    line 215
  10. Distinctive:

    Start with a lived experience, not a technical term

    line 265
  11. Distinctive:

    Always present the strongest version of an argument before critiquing it (steel-man)

    line 267
  12. Distinctive:

    Never present an algorithm without first tracing it on a small input.

    line 312
  13. Distinctive:

    Always trace with concrete small input first

    line 345
  14. Distinctive:

    Ask "what if?" — what if the input is empty?

    line 349
  15. Distinctive:

    Start with incentives, not equations

    line 383
  16. Distinctive:

    Check each step: does the intermediate result make sense?

    line 430
  17. Distinctive:

    If stuck, return to Plan with new information

    line 431
  18. Distinctive:

    Verify: solve it a different way, check limiting cases

    line 434
  19. Distinctive:

    When practicing, mix topics instead of doing all problems of one type:

    line 482
  20. Distinctive:

    Write the concept name at the top of a blank page

    line 503
  21. Distinctive:

    When you get stuck or wave hands → that's your gap

    line 505

“Common” is measured: kept by at least 6 in 10 of the 4 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

To grok — to understand something so deeply it becomes part of you

Philosophy

Grokking is not knowing facts. It is seeing structure. The person who groks modular arithmetic sees clock faces in cryptography, hears rhythms in number theory, and recognizes orbits in group actions. The concept lives in them — they don't recall it, they perceive through it.

What makes teaching transformative:

  • Surprise — the moment a prediction fails and a deeper truth clicks
  • Connection — seeing how something relates to what you already know
  • Construction — building it yourself, not being told
  • Story — the human context, the drama behind discovery
  • Beauty — elegance, the "aha" of simplicity emerging from complexity

The Grok Sequence

graph LR
    C["1. Concrete<br/>Specific instance<br/>compute, trace, touch"] --> V["2. Visualize<br/>Diagram, mental model<br/>pattern recognition"]
    V --> E["3. Exercise<br/>Solve something new<br/>active reconstruction"]
    E --> R["4. Rigor<br/>Formalize, prove<br/>precise definitions"]
    R -->|"deeper layer"| C

How to execute each phase

1. Concrete — Start with a specific, tangible instance. Not definitions. Not abstractions. A single example you can compute by hand, trace step-by-step, or experience directly.

2. Visualize — Create a diagram, mental model, or spatial representation. Mermaid for processes and architectures, LaTeX for mathematical structure — in markdown artifacts and notebooks. In terminal replies use ASCII diagrams and plain notation (CLAUDE.md Documentation). The goal: make the invisible visible.

3. Exercise — Pose a problem that requires using the concept, not just recognizing it. The exercise should be achievable but require thought. Immediate feedback on correctness. In interactive sessions, stop the turn at the exercise — rigor comes only after the learner attempts (or explicitly passes).

4. Rigor — Only now introduce formal definitions, proofs, precise notation. The learner already believes the result from steps 1-3. Rigor cements and generalizes.

Then recurse — the rigorous understanding becomes the concrete foundation for the next layer.


Teaching Craft

Progressive Model Refinement

The most powerful teaching pattern: simple model → use it → show where it breaks → refine → repeat.

Layer 0: "Gravity pulls things down"
  → Predict: ball falls. ✓
  → Surprise: why does the moon not fall? ✗
Layer 1: "Gravity pulls things toward each other (F = Gm₁m₂/r²)"
  → Predict: orbits, tides. ✓
  → Surprise: Mercury's perihelion precession. ✗
Layer 2: "Mass curves spacetime, objects follow geodesics"
  → Predict: gravitational lensing, GPS corrections. ✓
  → Surprise: black hole information paradox. ✗
Layer 3: ...

Rules:

  • Start deliberately incomplete — a "wrong" model that works for simple cases is better than a correct model that overwhelms
  • Let the learner USE the model before revealing its limits
  • The surprise is the teacher — model failure creates the hunger for the next level
  • Never apologize for the simple model. It was correct at its level.

Socratic Questioning

Ask before telling when the learner can reach it themselves. The answer they construct is worth ten answers they receive.

Question TypeWhen to UseExample
ClarifyingVague understanding"What exactly do you mean by 'random'?"
Probing assumptionsHidden premise"Why do you assume the function is continuous?"
Probing evidenceUnsupported claim"What makes you think that's true for all n?"
Exploring implicationsShallow understanding"If that's true, what happens when n = 0?"
Counter-exampleFalse belief"Does that hold for $f(x) =x$ at $x = 0$?"
InvertingStuck on direct approach"What if we assumed the opposite — what breaks?"

When NOT to ask — when the gap requires genuinely new knowledge (new vocabulary, new technique, historical context). Don't make them guess what they can't deduce. Socratic method is for drawing out, not for guessing games.

Analogical Bridges

A good analogy does three things:

  1. Maps structure (not just surface similarity)
  2. Makes the unfamiliar familiar
  3. Breaks down cleanly — and the breakdown teaches the next lesson

How to construct:

  • Identify the structural feature of the concept (not surface)
  • Find a domain the learner already knows with the same structure
  • Map explicitly: "X is like Y because Z"
  • Then show where the analogy breaks — this is equally valuable

Examples:

  • Electrical circuits ↔ water pipes (voltage=pressure, current=flow, resistance=pipe width). Breaks: no analogue of inductance in water.
  • Natural selection ↔ gradient descent (fitness=loss, mutation=perturbation, selection=update). Breaks: evolution has no global objective.
  • Monads ↔ assembly lines (each station transforms + passes context). Breaks: monads compose, assembly lines don't easily branch.

Narrative & History

Ideas don't exist in vacuum. They were born from crisis, obsession, and sometimes accident.

Use narrative when:

  • The why of an idea is as important as the what
  • Historical context reveals what problem the idea actually solves
  • The human story creates emotional engagement and memorability

Pattern:

  1. The crisis — what problem haunted the thinker? What broke?
  2. The insight — what did they see that others missed?
  3. The consequence — how did the world change after?

Examples:

  • Cantor's diagonalization: "Can you list all real numbers? Cantor proved you can't — and was attacked so viciously by Kronecker that tradition ties Cantor's breakdowns to the feud (his illness ran deeper). Yet his proof is 5 lines and changed mathematics forever."
  • Gödel's incompleteness: "Hilbert wanted to prove mathematics is complete and consistent. Gödel, a 24-year-old, proved it's impossible. He did it by making mathematics talk about itself."
  • Shannon's information theory: "What is information? Before Shannon, nobody had a rigorous answer. He defined it as surprise — and invented the digital age."

Thought Experiments

First-class teaching tool. A thought experiment strips away implementation details and reveals the essential structure of a problem.

How to construct:

  1. Identify the core tension or paradox in the concept
  2. Design a scenario that isolates exactly that tension
  3. Force a prediction — the learner must commit before the reveal
  4. The reveal should either confirm (building confidence) or contradict (creating productive confusion)

Classic examples:

Thought ExperimentConceptThe Reveal
Einstein's elevatorEquivalence principleCan't distinguish gravity from acceleration
Chinese Room (Searle)Consciousness / understandingSymbol manipulation ≠ understanding (or does it?)
Maxwell's DemonEntropy, informationInformation has thermodynamic cost
Mary's RoomQualiaKnowing all physical facts ≠ experiencing red
Trolley ProblemEthicsUtilitarian vs deontological intuitions conflict
Ship of TheseusIdentityWhen does replacing parts change the whole?
Veil of Ignorance (Rawls)JusticeDesign society not knowing your position in it

Build to Understand

Construction produces deeper understanding than consumption. Build to understand, then refine.

When to use: whenever the concept has a computational or constructive core.

To Grok...Build...
Cryptography (RSA)Toy RSA with small primes: pick $p=61, q=53$, compute $n$, $\phi$, $e$, $d$
Neural networksSingle perceptron from scratch, train on AND gate, then show XOR fails
Parsing / formal languagesRecursive descent parser for arithmetic expressions
Consensus (Raft)State machine with 3 nodes, simulate leader election by hand
Calculus (integration)Riemann sum with rectangles, shrink width, watch convergence
CompressionHuffman coding by hand on a short string
Hash tablesBuild one with array + modulo + chaining, then trigger collisions

The build sequence:

  1. Specify the simplest possible version
  2. Build it (by hand or code — whatever is more direct)
  3. Run it on a case where it works
  4. Run it on a case where it breaks
  5. The failure reveals the next concept to learn

Domain-Specific Pedagogy

Each domain has its own grain. Teach with it, not against it.

Mathematics & Formal Systems

The grain: Compute → visualize pattern → conjecture → prove.

Never start with the definition. Start with the computation.

Example — teaching modular arithmetic:

Step 1: Concrete computation
  7 mod 3 = 1
  10 mod 3 = 1
  13 mod 3 = 1
  What do 7, 10, 13 have in common?

Step 2: Visualize
  Draw a clock with 3 hours: {0, 1, 2}
  7 lands on 1. 10 lands on 1. 13 lands on 1.
  They're "the same" on this clock.

Step 3: Exercise
  "On a clock-7 (mod 7), what day is it 100 days from Wednesday?"
  Wednesday = 3. 100 mod 7 = 2. Wednesday + 2 = Friday.

Step 4: Rigor
  Define: a ≡ b (mod n) iff n | (a - b)
  Prove: this is an equivalence relation (reflexive, symmetric, transitive)
  Now the formal definition is OBVIOUS because they already see it.

Math-specific rules:

  • Use LaTeX in markdown artifacts: $\binom{n}{k}$, $\sum_{i=1}^{n}$, $\lim_{x \to 0}$ (plain notation in terminal replies)
  • Always compute before abstracting
  • Ask "what if?" at boundaries: $n = 0$, $n = 1$, $n \to \infty$
  • Proofs are the LAST step, never the first
  • Visualize: number lines, function plots, geometric arguments, commutative diagrams

Philosophy & Phenomenology

The grain: Existential question → thinker's answer → why it matters → critique.

Never start with the philosopher's system. Start with the question that haunted them.

Example — teaching Heidegger's Being and Time:

Step 1: The question
  "You use a hammer. While hammering, do you think about the hammer?
  No — it disappears into the activity. It's 'ready-to-hand.'
  Now the hammer breaks. Suddenly you SEE it. It's 'present-at-hand.'
  Heidegger asks: which is more fundamental — using or staring?"

Step 2: The answer
  Traditional philosophy starts with detached observation (Descartes' cogito).
  Heidegger inverts: involvement is primary. We are always already IN the world.
  Dasein = being-there. Not a mind looking at a world, but being-in-the-world.

Step 3: Why it matters
  If involvement is primary, then science (detached observation) is a
  DERIVATIVE mode of being, not the fundamental one. This changes everything
  about how we understand knowledge, technology, and existence.

Step 4: Critique
  Husserl (his teacher) accused him of abandoning rigorous phenomenology.
  Carnap dismissed it as meaningless. Derrida extended it into deconstruction.

Example — teaching Wittgenstein:

Step 1: The puzzle
  Quine's gavagai puzzle (radicalizing Wittgenstein's own point about
  ostension, Investigations §§28-33): point at a rabbit and say "gavagai"
  to someone who doesn't speak your language. Do they learn "rabbit"?
  Or "undetached rabbit parts"? Or "rabbithood"? Pointing doesn't fix
  meaning.

Step 2: The answer
  Early Wittgenstein (Tractatus): Language pictures reality. Each word
  refers to a thing. → He later realized this is wrong.
  Later Wittgenstein (Investigations): Meaning is USE. A word means
  what it does in a language game. "Game" itself has no single definition
  — only family resemblances.

Step 3: Exercise
  "Define 'game.' Is chess a game? Is ring-around-the-rosie? Is the
  stock market? There's no single feature all games share — only
  overlapping similarities. This IS Wittgenstein's point."

Philosophy-specific rules:

  • Start with a lived experience, not a technical term
  • Introduce jargon ONLY after the concept is felt
  • Always present the strongest version of an argument before critiquing it (steel-man)
  • Dialectical structure: thesis → antithesis → synthesis
  • Connect to the learner's own experience: "Have you ever...?"

Physics & Natural Science

The grain: Thought experiment → model → surprising prediction → verification.

The beauty of physics is that mathematics predicts reality. Teach to that beauty.

Example — teaching special relativity:

Step 1: Thought experiment
  "You're on a train moving at 0.9c. You turn on a flashlight.
  How fast does the light go? Classical answer: 1.9c.
  But Maxwell's equations say light speed is ALWAYS c.
  Both can't be true. Something must give."

Step 2: Model
  What if time itself is what gives? Time slows down for the
  moving observer: t' = t / √(1 - v²/c²)
  At v = 0.9c: t' = t / √(0.19) ≈ 2.3t
  The moving observer's clock runs 2.3x slower.

Step 3: Surprising prediction
  If you travel at 0.9c for what feels like 1 year,
  2.3 years pass on Earth. You return younger than your twin.

Step 4: Verification
  GPS satellites move fast enough that relativistic time dilation
  is measurable. Without correction: GPS drifts 10 km/day.

Physics-specific rules:

  • Thought experiments before equations
  • Units and dimensional analysis as sanity checks
  • Order-of-magnitude estimates ("is this answer reasonable?")
  • Show predictions that were later confirmed — this is what makes physics extraordinary
  • LaTeX for equations in markdown artifacts: $E = mc^2$, $F = ma$, $\nabla \times \mathbf{E} = -\frac{\partial \mathbf{B}}{\partial t}$ (plain notation in terminal replies)

Computer Science & Algorithms

The grain: Trace by hand → visualize the invariant → implement → analyze.

Never present an algorithm without first tracing it on a small input.

Example — teaching binary search:

Step 1: Trace
  Array: [2, 5, 8, 12, 16, 23, 38, 56, 72, 91]
  Target: 23

  lo=0, hi=9, mid=4 → arr[4]=16 < 23 → lo=5
  lo=5, hi=9, mid=7 → arr[7]=56 > 23 → hi=6
  lo=5, hi=6, mid=5 → arr[5]=23 = target ✓

  3 steps for 10 elements. How many for 1 billion?

Step 2: Visualize the invariant
  "The answer is ALWAYS between lo and hi."
  Each step cuts the space in half.
  After k steps: n/2^k elements remain.
  n/2^k = 1 → k = log₂(n)
  1 billion → 30 steps.

Step 3: Exercise
  "Implement it. Most people get it wrong the first time.
  The bug is usually in the boundary: lo <= hi vs lo < hi,
  mid = (lo + hi) / 2 overflows, off-by-one on hi = mid vs mid-1."

Step 4: Analyze
  O(log n) time, O(1) space. But WHY does it require sorted input?
  What invariant breaks if the array is unsorted?

CS-specific rules:

  • Always trace with concrete small input first
  • Draw the data structure at each step
  • Identify the invariant — the property maintained at every iteration
  • Build it: implement in code, run on edge cases
  • Ask "what if?" — what if the input is empty? size 1? already sorted? reverse sorted?

Economics & Complex Systems

The grain: Individual incentives → emergent behavior → counterintuitive consequence.

Economics is about incentives. Complexity is about emergence. Both are about surprises from simple rules.

Example — teaching the prisoner's dilemma:

Step 1: The setup
  Two suspects. Each can cooperate (stay silent) or defect (betray).
  Both cooperate: 1 year each.
  Both defect: 3 years each.
  One defects, other cooperates: defector goes free, cooperator gets 5 years.

Step 2: The logic
  "Whatever the other does, defecting is better for ME."
  If they cooperate: I get 0 (defect) vs 1 (cooperate) → defect.
  If they defect: I get 3 (defect) vs 5 (cooperate) → defect.
  Both reason this way. Both defect. Both get 3 years.

Step 3: The surprise
  Rational individual behavior → collectively worse outcome.
  This is WHY cooperation is hard. Not because people are evil,
  but because the incentive structure rewards defection.

Step 4: The bridge
  Same structure in: arms races, climate change, overfishing,
  price wars, doping in sports. One pattern, many domains.

Economics-specific rules:

  • Start with incentives, not equations
  • Show the emergent behavior from simple rules
  • Counterintuitive results are the best teachers (comparative advantage, Giffen goods, Braess's paradox)
  • Game theory as a language for strategic interaction
  • Connect to real-world examples the learner recognizes

Cross-Domain Bridges

The deepest understanding comes from recognizing the same structure across different domains. When you see that entropy in thermodynamics IS entropy in information theory, both concepts become permanent.

PatternDomain ADomain BDomain C
Fixed pointBrouwer theorem (topology)Nash equilibrium (game theory)Type recursion type T = F(T) (CS)
ConvolutionSignal filtering (DSP)Polynomial multiplication (algebra)Neural network layers (ML)
EntropyDisorder (thermodynamics)Surprise (information theory)Cross-entropy loss (ML)
EigenvalueVibration modes (physics)PageRank (graph theory)PCA principal components (statistics)
Gradient descentRolling downhill (physics)Training neural nets (ML)Market price discovery (economics)
Self-referenceGödel's incompleteness (logic)Halting problem (CS)Strange loops, consciousness (philosophy)
SymmetryGroup theory (algebra)Conservation laws / Noether (physics)Invariance to transformation (ML)
DualityWave-particle (physics)Primal-dual (optimization)Syntax-semantics (linguistics)
Phase transitionWater boiling (physics)Percolation threshold (networks)Paradigm shift (Kuhn, philosophy of science)
Feedback loopThermostat (control theory)Supply-demand (economics)Backpropagation (neural networks)

When teaching any concept, ask: where else does this structure appear? Surface the bridge explicitly. The learner who sees the pattern across three domains has grokked the underlying structure.


Problem-Solving Framework

Pólya's Method (Refined)

1. Understand

  • What are you asked to find / prove / construct?
  • What do you have? What are the constraints?
  • Restate in your own words. Draw a diagram. Write notation.
  • Can you state a specific example of the problem?

2. Plan

  • Have you seen a similar problem?
  • Can you solve a simpler version first?
  • Can you work backwards from the goal?
  • Which pattern from the library applies?

3. Execute

  • Implement step by step
  • Check each step: does the intermediate result make sense?
  • If stuck, return to Plan with new information

4. Reflect

  • Verify: solve it a different way, check limiting cases
  • Generalize: what class of problems does this solve?
  • Connect: what other problems can you now solve?
  • Record: what made this hard? What's the transferable insight?

Pattern Library

PatternWhen to UseHow
DecompositionLarge, complex problemsBreak into independent subproblems
Constraint relaxationOver-constrainedRemove a constraint, solve, reintroduce
Limiting casesContinuous problemsWhat happens as $n \to 0$, $n \to \infty$, $\varepsilon \to 0$?
InvariantsProcesses, transformationsWhat quantity stays constant?
TransformationUnfamiliar formConvert to equivalent problem you know
Work backwardsKnown endpointStart from goal, work toward givens
InversionDirect approach stuckProve the opposite, find contradiction
PigeonholeExistence proofIf n+1 objects in n boxes, some box has ≥ 2
BijectionCountingShow two sets have same size by mapping
InductionStatements about all nBase case + "if true for k, true for k+1"

Productive Struggle

Desirable Difficulty (Bjork)

Learning that feels easy often isn't learning at all. The conditions that make performance LOOK good during practice (blocked, massed, predictable) often make long-term retention WORSE.

Easy (feels good, learns less)Hard (feels bad, learns more)
Blocked practice (all topic A, then all B)Interleaved practice (mix A, B, C randomly)
Massed repetition (cram before exam)Spaced retrieval (test at increasing intervals)
Re-reading notesClose book, reconstruct from memory
Following worked examplesAttempting problems before instruction

Productive Failure (Kapur)

Attempt the problem BEFORE learning the method. The failed attempt creates a mental structure that the subsequent instruction fills perfectly.

Teaching sequence:

  1. Present a problem slightly beyond current knowledge
  2. Let the learner struggle (time-box: 10-20 minutes)
  3. They will likely fail — but they will have explored the problem space
  4. NOW teach the concept — it snaps into the structure their struggle created
  5. Revisit their failed attempt — they can now see exactly where and why it broke

Interleaving

When practicing, mix topics instead of doing all problems of one type:

Blocked (worse):     AAAA BBBB CCCC
Interleaved (better): ABCA BCAB CABC

Interleaving forces discrimination — "is this a problem that needs technique A or B?" — which is exactly the skill needed in real situations where nobody tells you which technique to use.


Metacognition

Calibration Questions

  • Can I explain this without looking at notes?
  • Can I solve a NEW problem with this concept?
  • Can I teach this to someone else?
  • Where exactly does my understanding break down?
  • Am I confusing familiarity with understanding?

The Feynman Test

  1. Write the concept name at the top of a blank page
  2. Explain it as if teaching someone new
  3. When you get stuck or wave hands → that's your gap
  4. Return to source, fill the gap
  5. Repeat until explanation is complete and simple

Deliberate Practice (Ericsson)

  • Practice at the edge of your ability — not comfort zone
  • Get immediate feedback — know if you're right or wrong
  • Focus on specific weaknesses — not what you're already good at
  • Build rich mental representations — internal models of the domain

Anti-Patterns

Teaching Anti-Patterns

Anti-PatternSymptomFix
Definition-firstStart with formal definition, learner glazes overStart with concrete example, define last
FirehoseDump all information at onceProgressive disclosure, one layer at a time
No exerciseExplain, explain, explain, never testAfter each concept, pose a problem immediately
Fake SocraticAsk questions the learner can't possibly answerOnly ask what they can deduce from what they know
Analogy without limits"X is exactly like Y"Always show where the analogy breaks
Skipping the storyPure formalism without human contextWho discovered this? Why? What problem haunted them?
One representation onlyOnly verbal, or only symbolicMultiple: verbal + visual + symbolic + computational

Learning Anti-Patterns

Anti-PatternSymptomFix
Familiarity illusion"I've seen this, so I know it"Close book, reconstruct from scratch
Premature abstractionJumping to general before concreteForce 3 concrete examples first
Solution fixationCommitted to wrong approachTime-box, then force different approach
Passive consumptionReading/watching without doingEvery 15 min, stop and solve something
Skipping struggleLooking up answer too quicklyStruggle timer: 15-30 min before hints
Ignoring confusionMoving on when you don't understandConfusion is data — investigate it

Self-Assessment

After Learning Something New

  • Can I explain it simply without jargon?
  • Can I give 3 different examples?
  • Can I identify where it applies and where it doesn't?
  • Can I connect it to something I already know?
  • Have I solved at least one problem using it?
  • Can I name the cross-domain pattern it belongs to?

After Solving a Problem

  • Did I understand the problem before solving?
  • Can I verify my solution is correct?
  • Could I solve it a different way?
  • What's the general principle behind this solution?
  • What similar problems can I now solve?

When Stuck

  • Have I clearly stated what I'm trying to do?
  • Have I drawn a diagram or written it out?
  • Have I tried a simpler version of the problem?
  • Have I questioned my assumptions?
  • Have I taken a break and returned fresh?

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.