Skip to main content
skill CX Codex

learning-opportunities — Claude Code skill: what it does

learning-opportunities adds optional 10–15 minute exercises to a Claude session, so the person who shipped the code can still explain how it works.

CC-BY-4.0 ★ 7,191 updated 2026-10-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add tech-leads-club/agent-skills --skill learning-opportunities -a claude-code
Open on GitHub

What learning-opportunities does

The skill offers a short exercise once something structural lands: a new module, a schema change, a refactor, a pattern you haven't met before. Permission comes first, asked in one sentence, and a refusal is the end of it.

Three formats sit inside. Guess the outcome before the answer appears. Sketch an approach before the real implementation is shown. Explain a piece of the system the way you would to someone joining the team. The rule the skill treats as central: stop at the question mark. No hints, no sample answers, no nudging. A wrong guess gets named as wrong, then the gap gets worked through. Reading code stays your job — early on you get a file and a line number, later just a question about where token refresh lives.

During an incident it is the wrong tool. The instructions rule out offering anything when the request sounds like “just ship it” or the work is a hotfix, and they cap a session at two exercises. The reasoning behind the method sits in references/PRINCIPLES.md; the licence is CC-BY-4.0.

What it helps with

  • check your guess about runtime behaviour before the code runs
  • learn an unfamiliar repo by locating files yourself
  • explain a module you just generated to a teammate
  • work through a wrong assumption instead of copying the fix
  • turn a refactor into something you can reason about later

Example prompts for the agent

  • Run a quick learning exercise on the auth middleware we just wrote.
  • Help me understand why this token check works.
  • Quiz me on the caching layer like I'm new to the team.

How to install learning-opportunities

1Skills CLI (Vercel)

npx skills add tech-leads-club/agent-skills --skill learning-opportunities -a claude-code

2Manually: put the files in place

~/.claude/skills/learning-opportunities/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/learning-opportunities/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about learning-opportunities

How do I install learning-opportunities in Claude Code?

Run npx skills add tech-leads-club/agent-skills --skill learning-opportunities -a claude-code; the skill ends up at ~/.claude/skills/learning-opportunities/SKILL.md.

What does learning-opportunities do?

It offers a short optional exercise after structural work — new modules, schema changes, refactors — then waits for your answer instead of explaining everything itself.

Will it interrupt a rush job?

It is built to stay quiet when you say “just ship it”, when you're on a hotfix, when you already declined, or after two exercises in one session.

Source text

SKILL.md · CC-BY-4.0
---
name: learning-opportunities
description: Facilitates deliberate skill development during AI-assisted coding. Offers interactive learning exercises after architectural work (new files, schema changes, refactors). Use when completing features, making design decisions, or when user asks to understand code better. Triggers on "learning exercise", "help me understand", "teach me", "why does this work", or after creating new files/modules. Do NOT use for urgent debugging, quick fixes, or when user says "just ship it".
license: CC-BY-4.0
metadata:
  original_author: Chris Hicks
  modified_by: Felipe Rodrigues - github.com/felipfr
  source: https://www.fightforthehuman.com
  version: 1.1.0
---

# Learning Opportunities

Facilitate deliberate skill development during AI-assisted coding sessions. Offer short, optional exercises that counteract passive consumption of AI-generated code.

When adapting techniques or making judgment calls about learning approaches, consult `references/PRINCIPLES.md` for the underlying learning science.

## When to offer exercises

Offer an optional 10-15 minute exercise after:

- Creating new files or modules
- Database schema changes
- Architectural decisions or refactors
- Implementing unfamiliar patterns
- Any work where the user asked "why" questions during development

Always ask before starting: "Would you like to do a quick learning exercise on [topic]? About 10-15 minutes."

## When NOT to offer

- User declined an exercise this session
- User already completed 2 exercises this session
- User signals urgency ("fix this quick", "just ship it", "deploy now")
- Pure debugging/hotfix context

Keep offers to one short sentence. Do not repeat or insist.

## Core principle: Pause for input

This is the most important rule. After posing a question:

1. **Stop generating immediately.** Do not continue after the question mark.
2. Do not generate suggested answers, hints, examples, or encouragement like "Think about..." or "Consider..."
3. Wait for the user's actual response before continuing.

Allowed after the question:

- "(Take your best guess — wrong predictions are useful data.)"
- "(Or we can skip this one.)"

After their response:

- If correct: confirm and deepen ("Exactly. And what would change if [variation]?")
- If wrong: **be direct** about what's incorrect, then explore the gap — this is high-value learning

## Exercise types

### 1. Predict then observe

Ask what they predict will happen in a specific scenario before revealing the answer.

```
Example:
User just created auth middleware.

Agent: "Would you like a quick learning exercise on middleware patterns?"
User: "sure"
Agent: "What do you think happens when a request hits your middleware with an expired token?

(Take your best guess — wrong predictions are useful data.)"

[STOP — wait for response]

After response:
Agent: "Actually [correct behavior]. The key difference is [explanation].
What surprised you about that?"

[STOP — wait for response]
```

### 2. Generate then compare

Ask them to sketch an approach before showing the actual implementation.

```
Example:
Agent: "Before I show you — how would you structure the error handling for this API endpoint?"

[STOP — wait for response]

After response:
Agent: "Here's what we went with: [implementation].
What's similar to your approach? What's different, and why do you think we chose this direction?"

[STOP — wait for response]
```

### 3. Teach it back

Ask them to explain a component as if to a new team member.

```
Example:
Agent: "Explain how the caching layer we just built works, as if I'm a new developer joining the project."

[STOP — wait for response]

After response:
Agent: "You nailed [specific part]. One thing to refine: [specific gap]."
```

## Hands-on code exploration

Prefer directing users to files over showing code snippets. Having learners locate code themselves builds codebase familiarity.

**Adjust guidance based on demonstrated familiarity:**

- Early: "Open `src/middleware/auth.ts`, around line 45. What does `validateToken` return?"
- Later: "Find where we handle token refresh."
- Eventually: "Where would you look to change how session expiry works?"

After they locate code, prompt self-explanation:

"You found it. Before I say anything — what do you think this line does?"

## Techniques to weave in naturally

- **"Why" questions:** "Why did we use a Map here instead of an object?"
- **Transfer prompts:** "This is the strategy pattern. Where else in this codebase might it apply?"
- **Varied context:** "We used this for auth — how would you apply it to API rate limiting?"
- **Error analysis:** "Here's a bug someone might introduce — what would go wrong and why?"

## Anti-patterns to avoid

- Dumping multiple questions at once
- Softening wrong answers into ambiguity ("well, that's partially right...")
- Offering exercises more than twice per session
- Making exercises feel like tests rather than exploration
- Continuing to generate after posing a question

© tech-leads-club · CC-BY-4.0 · tech-leads-club/agent-skills

Similar skills

All skills for Agent setup: memory, context, orchestration →

From the same set130

The whole set →
tactical-ddd Audits domain models for anemia and refactors them into rich aggregates using tactical DDD patterns in Claude Code. CX Codex +1 ★ 7,191repo stars nx-workspace nx-workspace — a skill for exploring an Nx monorepo from the CLI: list projects, read resolved config, find affected projects and wire affected commands into CI. CX Codex +1 ★ 7,191repo stars perf-web-optimization perf-web-optimization guides front-end performance tuning by shrinking JS bundles, deferring heavy scripts, and configuring cache headers. Best when pages load slowly or fail speed benchmarks. CX Codex +1 ★ 7,191repo stars state-context-interface The state-context-interface rule separates a component’s UI from its state implementation with a context split into state, actions, and meta. Use it when the same UI needs to work with different providers. CX Codex +1 ★ 7,191repo stars confluence-assistant confluence-assistant operates Confluence spaces through Atlassian MCP tools. Helps Claude Code search team documentation, create structured pages, and update existing entries using Markdown. CX Codex +1 ★ 7,191repo stars security-threat-model security-threat-model reads your repository and writes a threat model: trust boundaries, assets, realistic abuse paths and mitigations, saved as a Markdown file. CX Codex +1 ★ 7,191repo stars modular-decomposition modular-decomposition walks a monolith through five analysis steps before splitting it into modules: sizing and listing components, finding duplicate domain logic, hierarchy, coupling, and domain grouping. CX Codex +1 ★ 7,191repo stars tlc-plan tlc-plan turns PRDs, tickets, and task threads into an unambiguous implementation plan. It resolves all edge cases through direct questions before writing specs. CX Codex +1 ★ 7,191repo stars

Project sponsors

Companies that keep this analytics open