@olegkoval/agent-skills 1.16.0 → 1.18.0

package/packages/software-development/apple-store-submit/adapters/grok/skills/apple-store-submit/SKILL.md

@@ -0,0 +1,158 @@
+---
+name: apple-store-submit
+description: Handle Apple App Store rejection emails end-to-end — parse rejection reasons, create a fix plan, implement code changes (privacy strings, entitlements, sandbox), navigate App Store Connect to update metadata, and resubmit. Use when an app receives a rejection or when preparing a first-time submission.
+license: MIT
+allowed-tools: Bash, Read, Write, Edit
+compatibility: Codex, Claude Code, Cursor, GitHub Copilot, Windsurf, Kiro, and other Agent Skills compatible tools. Requires Xcode, an Apple Developer account, and App Store Connect access.
+metadata:
+  targets: [_source-only]
+  author: Oleg Koval
+  tags:
+    - apple
+    - app-store
+    - ios
+    - macos
+    - xcode
+    - submission
+    - rejection
+---
+<!-- Generated by scripts/build-adapters.sh. Do not edit directly. -->
+
+> 🤖 *Auto-generated by **weekly-pattern-learner** · App Store rejection handling workflow observed in FocusNotch App Store session, Jun 2026 (92 user turns covering rejection → plan → code fixes → metadata → resubmit)*
+
+# Apple App Store Submission & Rejection Handling
+
+## Overview
+
+Parse Apple rejection feedback, implement targeted fixes, update App Store Connect metadata, and resubmit — covering the complete cycle from rejection email to approved build.
+
+## When to Use
+
+- Apple review team sends a rejection email
+- App fails automated pre-review checks (binary rejected at upload)
+- Preparing metadata for first-time submission (screenshots, keywords, privacy labels)
+- Resolving App Store Connect errors before submitting for review
+
+## Workflow
+
+### 1. Parse the Rejection
+
+Read the full rejection email. Extract and list:
+
+- **Guideline numbers** violated (e.g., 2.1, 4.2.0, 5.1.1)
+- **Code-level issues** — missing entitlements, incorrect privacy strings, sandbox violations
+- **Metadata issues** — wrong screenshot sizes, subtitle policy, keyword stuffing
+- **UX issues** — crashes described by reviewer, broken flows, missing functionality
+
+Create a numbered fix plan: one item per rejection point, with the type of fix needed.
+
+### 2. Classify Fixes by Type
+
+| Type | Location |
+|------|----------|
+| Privacy usage strings missing | `Info.plist` |
+| Entitlement missing/wrong | `<AppName>.entitlements` |
+| Crash or broken feature | Source code |
+| Screenshots wrong size/content | App Store Connect |
+| Keywords/subtitle/description | App Store Connect |
+| Build number conflict | Xcode + App Store Connect |
+
+### 3. Implement Code Fixes
+
+**Privacy permission strings** (`Info.plist`):
+
+```xml
+<key>NSMicrophoneUsageDescription</key>
+<string>Used for voice input during focus sessions.</string>
+
+<key>NSCalendarsUsageDescription</key>
+<string>Used to sync tasks with your calendar.</string>
+```
+
+**Entitlements** (`<AppName>.entitlements`):
+
+```xml
+<key>com.apple.security.app-sandbox</key>
+<true/>
+<key>com.apple.security.network.client</key>
+<true/>
+<key>com.apple.security.files.user-selected.read-write</key>
+<true/>
+```
+
+**Sandbox violations** — remove `NoEscapeBlock` patterns, replace deprecated APIs, use only sandboxed file access via Security-Scoped Bookmarks when needed.
+
+### 4. Build and Archive
+
+```bash
+# Clean build
+xcodebuild clean \
+  -scheme <AppName> \
+  -destination 'generic/platform=macOS'
+
+# Archive
+xcodebuild archive \
+  -scheme <AppName> \
+  -archivePath build/<AppName>.xcarchive \
+  -destination 'generic/platform=macOS'
+
+# Export for App Store
+xcodebuild -exportArchive \
+  -archivePath build/<AppName>.xcarchive \
+  -exportPath build/export \
+  -exportOptionsPlist ExportOptions.plist
+```
+
+Validate codesigning before upload:
+
+```bash
+codesign --verify --deep --strict --verbose=4 build/export/<AppName>.app
+spctl --assess --verbose=4 build/export/<AppName>.app
+```
+
+### 5. Update App Store Connect Metadata
+
+Navigate: **My Apps → [App] → App Store tab**
+
+Common metadata fixes:
+
+- **App name**: max 30 chars
+- **Subtitle**: max 30 chars, no duplicate keywords from the title field
+- **Keywords**: 100-char total limit, comma-separated, no spaces after commas
+- **Screenshots**: exact pixel dimensions per device type (check Apple's current spec)
+- **Privacy Nutrition Labels**: must accurately reflect data collected/linked to user
+- **Build selection**: select the newly uploaded build before submitting
+
+### 6. Write Reviewer Notes
+
+In the submission form, fill **Notes for Reviewer**:
+
+- Explain each rejection point and what was changed
+- Reference specific guideline numbers: "Addressing 2.1 — added NSMicrophoneUsageDescription to Info.plist"
+- If a feature requires special credentials to test, provide test account details
+
+### 7. Submit and Track
+
+1. Upload via **Xcode Organizer → Distribute App → App Store Connect**
+2. In App Store Connect: select the new build, fill notes, **Submit for Review**
+3. Typical re-review: 24–48h
+4. If rejected again: respond in the **Resolution Center** thread (same case number)
+5. Escalate via Resolution Center for policy disagreements — do not open a new submission
+
+## Build Number Protocol
+
+Apple rejects builds with a duplicate build number. Increment `CFBundleVersion` in `Info.plist` or Xcode target settings before every upload:
+
+```bash
+# Bump build number (e.g., 9 → 10)
+xcrun agvtool new-version -all 10
+```
+
+## Verification
+
+- [ ] Every rejection guideline number has a corresponding fix in the plan
+- [ ] `xcodebuild archive` exits 0 with no warnings about entitlements
+- [ ] `codesign --verify` passes
+- [ ] App Store Connect shows build status as "Ready to Submit"
+- [ ] Reviewer Notes reference each changed item
+- [ ] Build number is higher than any previously uploaded build

package/packages/software-development/cloudflare-block-countries/adapters/grok/plugin.json

@@ -0,0 +1,6 @@
+{
+  "name": "olko:cloudflare-block-countries",
+  "version": "0.1.0",
+  "description": "Block specific countries via Cloudflare WAF Custom Rules using the Cloudflare API. Handles creating new rulesets and updating existing ones across single or multiple zones.",
+  "skills": "skills/"
+}

package/packages/software-development/cloudflare-block-countries/adapters/grok/skills/cloudflare-block-countries/SKILL.md

@@ -0,0 +1,177 @@
+---
+name: cloudflare-block-countries
+description: 'Block specific countries via Cloudflare WAF Custom Rules using the Cloudflare API. Use when user wants to geo-block traffic, block countries in Cloudflare, set up WAF country rules, or mentions blocking regions. Handles both creating new rulesets and updating existing ones.'
+license: MIT
+allowed-tools: Bash
+compatibility: Codex, Claude Code, Cursor, GitHub Copilot, Windsurf, Kiro, and other Agent Skills compatible tools. Requires curl and jq.
+metadata:
+  targets: [_source-only]
+  author: Oleg Koval
+  tags:
+    - cloudflare
+    - waf
+    - security
+    - geo-blocking
+    - firewall
+---
+<!-- Generated by scripts/build-adapters.sh. Do not edit directly. -->
+
+# Cloudflare Country Block via WAF Custom Rules
+
+Block traffic from specific countries using Cloudflare WAF Custom Rules and the Cloudflare API.
+
+## Prerequisites
+
+- Cloudflare API Token with `Zone:Rulesets:Edit` permission
+- Zone ID for the target domain
+- `curl` and `jq` installed
+
+## Workflow
+
+### 1. Get Zone IDs
+
+```bash
+curl -s -X GET \
+  "https://api.cloudflare.com/client/v4/zones?account.id=YOUR_ACCOUNT_ID&status=active" \
+  -H "Authorization: Bearer YOUR_API_TOKEN" \
+  -H "Content-Type: application/json" | jq '.result[] | {name: .name, id: .id}'
+```
+
+### 2. Check Existing Custom Firewall Rulesets
+
+```bash
+curl -s -X GET \
+  "https://api.cloudflare.com/client/v4/zones/YOUR_ZONE_ID/rulesets" \
+  -H "Authorization: Bearer YOUR_API_TOKEN" \
+  -H "Content-Type: application/json" | \
+  jq '.result[] | select(.phase == "http_request_firewall_custom")'
+```
+
+If the output is empty — no existing ruleset. Go to **3a**. If a ruleset exists, note its `id` and go to **3b**.
+
+### 3a. Create NEW Ruleset with Block Rule
+
+```bash
+curl -s -X POST \
+  "https://api.cloudflare.com/client/v4/zones/YOUR_ZONE_ID/rulesets" \
+  -H "Authorization: Bearer YOUR_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  --data '{
+    "name": "default",
+    "description": "WAF Custom Rules",
+    "kind": "zone",
+    "phase": "http_request_firewall_custom",
+    "rules": [
+      {
+        "action": "block",
+        "description": "Block traffic from sanctioned countries",
+        "enabled": true,
+        "expression": "(ip.src.country in {\"RU\" \"BY\" \"IR\" \"KP\"})"
+      }
+    ]
+  }' | jq '.success'
+```
+
+### 3b. Update EXISTING Ruleset
+
+```bash
+curl -s -X PUT \
+  "https://api.cloudflare.com/client/v4/zones/YOUR_ZONE_ID/rulesets/RULESET_ID" \
+  -H "Authorization: Bearer YOUR_API_TOKEN" \
+  -H "Content-Type: application/json" \
+  --data '{
+    "description": "WAF Custom Rules",
+    "rules": [
+      {
+        "action": "block",
+        "description": "Block traffic from sanctioned countries",
+        "enabled": true,
+        "expression": "(ip.src.country in {\"RU\" \"BY\" \"IR\" \"KP\"})"
+      }
+    ]
+  }' | jq '.success'
+```
+
+### 4. Verify the Rule is Active
+
+```bash
+curl -s -X GET \
+  "https://api.cloudflare.com/client/v4/zones/YOUR_ZONE_ID/rulesets/RULESET_ID" \
+  -H "Authorization: Bearer YOUR_API_TOKEN" \
+  -H "Content-Type: application/json" | jq '.result.rules'
+```
+
+## Country Codes Reference
+
+| Code | Country |
+|------|---------|
+| `RU` | Russia |
+| `BY` | Belarus |
+| `IR` | Iran |
+| `KP` | North Korea |
+| `CN` | China |
+| `CU` | Cuba |
+| `SY` | Syria |
+| `VE` | Venezuela |
+
+## WAF Expression Examples
+
+```
+# Block multiple countries
+(ip.src.country in {"RU" "BY" "IR" "KP"})
+
+# Block country + specific ASN
+(ip.src.country eq "RU") or (ip.geoip.asnum eq 12345)
+
+# Block all except allowlisted IPs
+(ip.src.country in {"RU" "BY"}) and not (ip.src in {1.2.3.4/32})
+```
+
+## Multi-Zone Script
+
+To apply the same block rule across multiple zones:
+
+```bash
+#!/usr/bin/env bash
+API_TOKEN="YOUR_API_TOKEN"
+ZONES=("ZONE_ID_1" "ZONE_ID_2" "ZONE_ID_3")
+EXPRESSION='(ip.src.country in {"RU" "BY" "IR" "KP"})'
+
+for ZONE_ID in "${ZONES[@]}"; do
+  EXISTING=$(curl -s -X GET \
+    "https://api.cloudflare.com/client/v4/zones/$ZONE_ID/rulesets" \
+    -H "Authorization: Bearer $API_TOKEN" \
+    -H "Content-Type: application/json" | \
+    jq -r '.result[] | select(.phase == "http_request_firewall_custom") | .id')
+
+  if [ -z "$EXISTING" ]; then
+    METHOD="POST"
+    URL="https://api.cloudflare.com/client/v4/zones/$ZONE_ID/rulesets"
+    DATA=$(jq -n --arg expr "$EXPRESSION" '{
+      name: "default", description: "WAF Custom Rules",
+      kind: "zone", phase: "http_request_firewall_custom",
+      rules: [{action: "block", description: "Block sanctioned countries", enabled: true, expression: $expr}]
+    }')
+  else
+    METHOD="PUT"
+    URL="https://api.cloudflare.com/client/v4/zones/$ZONE_ID/rulesets/$EXISTING"
+    DATA=$(jq -n --arg expr "$EXPRESSION" '{
+      description: "WAF Custom Rules",
+      rules: [{action: "block", description: "Block sanctioned countries", enabled: true, expression: $expr}]
+    }')
+  fi
+
+  RESULT=$(curl -s -X "$METHOD" "$URL" \
+    -H "Authorization: Bearer $API_TOKEN" \
+    -H "Content-Type: application/json" \
+    --data "$DATA" | jq '.success')
+
+  echo "Zone $ZONE_ID: $RESULT"
+done
+```
+
+## Notes
+
+- `PUT` on an existing ruleset **replaces all rules** in it. Include all rules in the payload if the ruleset already has other rules.
+- WAF Custom Rules require a Cloudflare plan that supports rulesets (Free includes basic WAF; Pro/Business/Enterprise for full custom rules).
+- Changes are applied globally within seconds; no cache purge needed.

package/packages/software-development/crash-course/SKILL.md

@@ -0,0 +1,270 @@
+---
+name: crash-course
+description: 'Expert tutor that gets you from zero to working knowledge on any TOPIC fast, grounded in real sources rather than generic filler. Use this whenever the user wants to LEARN, understand, ramp up on, or get up to speed on something and has limited time: a new codebase or project they have been assigned, an unfamiliar technology or framework, a domain concept, an API, a paper, a business area. Triggers on phrases like "help me learn X", "I have N hours to understand X", "teach me X", "get me up to speed on X", "crash course on X", "quiz me on X", "make me a cheat sheet for X", "explain X like I am 5", "I got assigned X and have no context". Runs a timed 4-hour sprint by default, or a single mode on request (cheat sheet, learning ladder, quiz-me, Feynman loop, resource curation). Prefer this over answering a learning request directly, because the value is the structured, interactive, source-grounded teaching loop, not a one-shot dump.'
+license: MIT
+allowed-tools: Read, Grep, Glob, Bash, WebSearch, WebFetch
+compatibility: Codex, Claude Code, Cursor, GitHub Copilot, Windsurf, Kiro, and other Agent Skills compatible tools. Teaches from whatever sources are reachable; a codebase topic benefits from repo access and relevant issue/doc/chat tools.
+metadata:
+  targets: [_source-only]
+  author: Oleg Koval
+  tags:
+    - learning
+    - tutor
+    - onboarding
+    - study
+    - feynman
+    - active-recall
+---
+
+# Crash Course
+
+An expert tutor for rapid, durable learning of any topic. The learner is smart and
+time-boxed. Your job is not to lecture. It is to build a real mental model, prove it
+with recall, and leave behind artifacts they can reuse.
+
+Two things make this skill better than pasting a prompt into a chat window:
+
+1. **You become an expert on the real topic first** (Step 0), from actual sources, so
+   every explanation is true and specific rather than plausible-sounding filler.
+2. **You teach interactively** and hold the learner to active recall, instead of
+   dumping a wall of text they will forget by lunch.
+
+## Step 0: Scope and become the expert (do this before teaching anything)
+
+Never teach from memory alone. First pin the topic, then go read the ground truth.
+
+1. **Confirm scope in one line.** What exactly are we learning, to what depth, and
+   why? If the request is vague ("learn the ELC project"), ask one clarifying
+   question, then proceed. Do not over-interview.
+
+2. **Gather real sources** appropriate to the topic. Spend a few minutes here; it
+   pays for the whole session.
+   - **A codebase / work project:** read the README, the key PRs and their
+     descriptions, issue-tracker tickets, docs, and relevant chat threads. Use
+     whatever tools and CLIs are available (`gh`, repo search, and any connected
+     issue/doc/chat integrations). Skim the actual entry-point files, not just docs.
+   - **A public technology / concept / paper:** use web search and fetch the primary
+     sources (official docs, the paper itself, the canonical guide). Prefer source
+     material over blog summaries.
+   - Note the 3 to 5 sources you actually used. If you could not verify something,
+     say so rather than inventing it.
+
+3. **Find the 80/20.** From the sources, identify the ~20% of concepts that unlock
+   ~80% of understanding. That set becomes the spine of the session. State it
+   explicitly to the learner before diving in.
+
+## The teaching contract (how to behave in every mode)
+
+These are the habits that separate real tutoring from a text dump. Follow them
+throughout.
+
+- **One thing at a time, then wait.** When you ask a quiz question or ask the learner
+  to explain something back, ask ONE and stop. Do not answer your own question. Do
+  not pre-write the next three. Real recall only happens when they actually respond.
+- **Ground every claim in the sources from Step 0.** Use the project's real names,
+  files, endpoints, and numbers. Specificity is what makes it stick and what makes it
+  trustworthy.
+- **ELI5 on demand.** If a concept is landing hard, or the learner asks, re-explain it
+  as if to a curious 12-year-old: plain words, a real-world analogy, no jargon. Then
+  climb back up to the precise version once the intuition is there.
+- **Adapt to their answers.** Right answer, push harder. Weak answer, find the exact
+  gap and re-teach only that. Do not restart from scratch.
+- **Leave an artifact.** Every mode ends with something saveable: a cheat sheet, clean
+  notes, a score with a revision plan. Offer to save it as a note or file.
+- **Honesty about limits.** If the sources did not cover something, teach the shape of
+  the gap and where they would find the answer, rather than bluffing.
+
+## Modes
+
+Default to the **4-Hour Sprint** unless the learner asks for a specific mode. If they
+have a different time budget, scale the blocks proportionally (a 1-hour version is
+just Block 1 plus a short version of Block 3). You can also run any single mode on its
+own, or chain them.
+
+| Mode | Use when |
+|------|----------|
+| **4-Hour Sprint** | "I have ~4 hours to learn X" |
+| **One-page cheat sheet** | "make me a cheat sheet / quick reference" |
+| **Learning ladder** | "break X into levels, I want to build foundations" |
+| **Quiz me until I break** | "test me / find the edge of my understanding" |
+| **Feynman loop** | "teach me and make me explain it back" |
+| **Find the signal** | "what are the best resources to learn X" |
+
+The Sprint embeds the Feynman loop, flashcards, and a final cheat sheet. The
+standalone protocols for the other modes are in the "Standalone modes" section at the
+end of this file.
+
+## The 4-Hour Sprint
+
+Four 60-minute blocks. Blocks 1 to 2 build the model; Blocks 3 to 4 prove it by doing.
+Announce the plan up front (the four block titles and what each delivers), then run
+one block at a time. At each block boundary, pause: give a 2-line recap and ask if
+they want a break, a re-explain, or to continue.
+
+Keep the learner active the whole way. A block is not you talking for 60 minutes; it
+is short explanation, then a check, then their turn.
+
+### Block 1 (0:00 to 1:00) — The map and the vocabulary
+
+Goal: the learner can say what the topic *is*, why it exists, and name its main parts.
+
+- Open with the 80/20 spine from Step 0: the handful of concepts everything hangs on.
+- Teach each core concept in a tight loop: a plain-language definition, one concrete
+  example from the real sources, then a one-line check question. Wait for the answer.
+- Maintain a running glossary of the key terms and their one-line definitions.
+- **End-of-block quiz (3 questions), one at a time.** Cover: what it is, why it
+  exists, and the single most important distinction in the topic. Grade briefly,
+  fill gaps.
+
+### Block 2 (1:00 to 2:00) — How the pieces fit together
+
+Goal: the learner understands the flow, the interactions, and the "why it is built
+this way" tradeoffs.
+
+- Move from nouns to verbs: how does data/control actually move through the system or
+  argument? Draw it as a simple text diagram or numbered flow.
+- Teach the 2 to 3 decisions or tradeoffs that a practitioner argues about. This is
+  where real understanding lives.
+- Introduce the sharp edges: the gotchas, the known bugs, the "this looks wrong but
+  is intentional" spots you found in the sources.
+- **End-of-block quiz (3 questions), one at a time**, focused on flow and tradeoffs,
+  not vocabulary. Then have the learner give a 3-sentence Feynman-style summary of the
+  whole topic so far; correct only what they missed.
+
+### Block 3 (2:00 to 3:00) — Build something (30-minute mini-project)
+
+Goal: touch the real thing. Understanding without contact is fragile.
+
+- Design a **30-minute mini-project** scoped to what they just learned and to what is
+  actually runnable in their environment. For a codebase: run it locally, trace one
+  request end to end, add a log line and see it fire, or write one small failing test
+  and make it pass. For a concept: a tiny worked calculation, a small script, a
+  hand-derivation.
+- Give it as numbered steps with a clear "done looks like this" at the end.
+- Let them drive. When they hit an error, coach toward the fix; do not just hand it
+  over. Use the remaining time in the block to debug together.
+
+### Block 4 (3:00 to 4:00) — Prove it and lock it in
+
+Goal: confirm retention and produce the take-home artifacts.
+
+- **Feynman pass:** ask the learner to teach the whole topic back to you in their own
+  words as if you were a new teammate. Note every gap, misconception, or hand-wave.
+  Re-teach only those. Ask them to explain the weak parts again, cleaner. Loop until
+  the explanation is accurate and simple.
+- **Final 10-question flashcard quiz**, one at a time, difficulty ramping from basic
+  recall to expert judgment. After each: score out of 10, what was right, the exact
+  gap, and a one-line re-explanation of only the missed part.
+- **Wrap-up artifact:** produce a one-page cheat sheet (format in the Standalone modes
+  section) plus a short scorecard: final score, strongest areas, weakest areas, and a
+  3-bullet revision plan. Offer to save both.
+
+## Example: kicking off a sprint
+
+Input: "I got assigned the loyalty proxy and have ~4 hours, no context."
+
+Good opening move: confirm scope in one line, then do Step 0 (read the repo README,
+the relevant PRs, the tickets, the relevant chat threads), extract the 80/20 spine,
+and only then present the four-block plan and start Block 1. Do not start lecturing
+from memory before reading the actual code.
+
+---
+
+# Standalone modes
+
+Each mode can run on its own. They all assume Step 0 (become the expert from real
+sources) and the teaching contract above still apply: ground everything in real
+sources, one question at a time, ELI5 on demand, end with a saveable artifact.
+
+## One-page cheat sheet
+
+A compact review sheet the learner can scan in 5 minutes right before they need the
+topic. It is a study map, not an explanation. Keep it dense, visual, and scannable.
+
+Produce exactly these sections:
+
+1. **What it is** — one or two sentences, plain language.
+2. **Core concepts / rules / steps** — the load-bearing ideas as tight bullets, not
+   paragraphs. Include formulas or exact command/endpoint names where they apply.
+3. **Mental model** — one simple text diagram, flowchart, table, or analogy that makes
+   the whole thing click. Only include it if it genuinely helps.
+4. **3 to 5 real examples** — concrete, from the actual sources, showing the topic in
+   use.
+5. **Common mistakes / confusing parts** — the traps, with the correction.
+6. **Before you use this checklist** — 3 to 6 quick pre-flight checks.
+7. **5 rapid-fire questions** — memory checks. Put answers below a divider so they can
+   self-test first.
+
+Then offer to save it. Avoid theory padding; if a line is not useful under time
+pressure, cut it.
+
+## Learning ladder
+
+Break the topic into 5 difficulty levels so the learner climbs without skipping
+foundations. Present the ladder, then let them tell you which rung they are on.
+
+For **each** level give:
+1. Level name
+2. What you should understand at this stage
+3. What mastery looks like here
+4. The most important concepts/skills to focus on
+5. One milestone that proves you are ready to move up
+6. One hands-on exercise or mini-project
+7. Common mistakes at this level
+8. A single self-check question to gate the next level
+
+Fixed structure: **Level 1: Complete Beginner**, **Level 2: Basic Understanding**,
+**Level 3: Practical User**, **Level 4: Problem Solver**, **Level 5: Confident
+Practitioner**.
+
+Keep it practical and about real progress. Do not overload with theory. End by
+pointing them at the exercise for whatever level they are currently on.
+
+## Quiz me until I break
+
+A strict-but-helpful examiner using active recall to find the exact edge of the
+learner's understanding.
+
+Rules:
+- Ask **10 questions, one at a time**, and WAIT for each answer. Never batch.
+- Difficulty ramp: Q1 to Q3 beginner, Q4 to Q6 intermediate, Q7 to Q8 advanced,
+  Q9 to Q10 expert.
+- After each answer, do four things: grade it out of 10; say what they got right; name
+  the exact gap or weak point; re-explain only the missed part, simply.
+- If an answer is weak, ask one targeted follow-up before moving on. If it is strong,
+  nudge the difficulty up.
+- Do not reveal all answers at once. Make it feel like a real oral exam.
+
+At the end give: final score, strongest areas, weakest areas, a short revision plan,
+and 5 final challenge questions to push toward mastery. Offer to save the scorecard.
+
+## Feynman loop
+
+Deep understanding by forcing the learner to teach it back.
+
+1. First explain the topic simply, as if to a 12-year-old: plain words, real-life
+   examples, analogies, no needless jargon, short.
+2. Ask the learner to explain it back in their own words.
+3. Review their explanation: note what they got right; find every gap, mistake, or
+   missing idea; re-teach only the wrong or missing parts; ask them to explain again,
+   cleaner.
+4. Repeat the loop until their explanation is simple, accurate, and complete. Do not
+   advance while it is still muddy. Correct gently but clearly; reach for an example
+   whenever they are confused.
+
+End with a final clean explanation of the topic they can save as notes.
+
+## Find the signal
+
+Curate the 5 highest-leverage resources so the learner does not waste time on noise.
+Resources can be books, courses, videos, docs, newsletters, communities, or people to
+follow. For a work/codebase topic, "resources" can include the specific internal docs,
+PRs, and people who own the area.
+
+For **each** of the 5 resources give: name; type; why it is worth their time; what
+specific part of the topic it teaches; best learner type for it; difficulty
+(beginner/intermediate/advanced); how to use it effectively; one warning about what
+NOT to waste time on.
+
+Then rank the 5 in the best order to consume them, and give a simple 7-day learning
+path using only those resources. Favor quality over quantity. Signal, not noise.

package/packages/software-development/crash-course/adapters/claude/plugin.json

@@ -0,0 +1,5 @@
+{
+  "name": "olko-crash-course",
+  "description": "Expert tutor for rapid, source-grounded learning of any topic: a timed 4-hour sprint plus cheat-sheet, learning-ladder, quiz-me, Feynman, and resource-curation modes.",
+  "skills": "./skills"
+}