pattern-coach — Claude Code skill: DSA coaching and setup
The pattern-coach Claude Code skill teaches algorithm patterns through guided questions instead of immediate solutions. It engages when someone is stuck on a LeetCode problem or asks how to approach one.
MIT ★ 345 updated 2026-11-14
/plugin marketplace add nishant-Tiwari24/cracked
/plugin install cracked@crackedWhat pattern-coach does
The skill coaches users through algorithm problems without leading with a finished answer. It first asks what they have tried, then guides them from a brute-force approach toward repeated work, useful clues, and the pattern behind the problem.
After a problem is solved, the agent writes a pattern card with signals, a code template, and common pitfalls. It then gives a different problem to test transfer and lists more problems from easy to hard. For profile details and progress logging, it calls the Skill tool with cracked-profile. If that tool is unavailable, open the relevant skill's SKILL.md in core/, interview/, profile/, or strategy/ instead.
What it helps with
- identify an algorithm pattern for a LeetCode problem
- spot repeated work in a brute-force approach
- test pattern recognition on a new problem
- record a pattern's signals, template, and pitfalls
Example prompts for the agent
- I’m stuck on a LeetCode problem. Help me find an approach without giving me the solution straight away.
- Teach me sliding window with an easy problem, asking one question at a time.
- Give me another problem to test whether I can recognise BFS after our first walkthrough.
How to install pattern-coach
1Plugin marketplace
/plugin marketplace add nishant-Tiwari24/cracked/plugin install cracked@crackedThis installs the whole cracked plugin with all its skills
2Skills CLI (Vercel)
npx skills add nishant-Tiwari24/cracked --skill pattern-coach -a claude-code3Manually: put the files in place
~/.claude/skills/pattern-coach/SKILL.mdCopy the whole skill folder; for one project use .claude/skills/pattern-coach/
1Skills CLI (Vercel)
npx skills add nishant-Tiwari24/cracked --skill pattern-coach -a codex2Manually: put the files in place
.agents/skills/pattern-coach/SKILL.mdFor all projects use ~/.agents/skills/
1Skills CLI (Vercel)
npx skills add nishant-Tiwari24/cracked --skill pattern-coach -a cursor2Manually: put the files in place
.cursor/skills/pattern-coach/SKILL.mdCursor also reads .agents/skills/ and .claude/skills/
1GitHub CLI
gh skill install nishant-Tiwari24/cracked skills/interview/pattern-coach2Manually: put the files in place
.github/skills/pattern-coach/SKILL.md1Skills CLI (Vercel)
npx skills add nishant-Tiwari24/cracked --skill pattern-coach -a gemini-cli2Platform CLI
gemini skills install https://github.com/nishant-Tiwari24/cracked --path skills/interview/pattern-coachManually: put the files in place
.devin/skills/pattern-coach/SKILL.mdThe legacy .windsurf/skills/ path still works
Claude.ai
Zip the folder and upload it in Settings → Capabilities → Skills
Step by step, with commands for each platform: How to install skills in Claude Code: five ways
Questions about pattern-coach
How do I install pattern-coach in Claude Code?
Add the marketplace with /plugin marketplace add nishant-Tiwari24/cracked, then install the skill with /plugin install cracked@cracked.
What does pattern-coach do?
It guides users toward recognising algorithm patterns by asking questions about their own attempts. It gives the full solution only after a second request.
How does pattern-coach check whether a pattern has been learned?
After the user solves a problem, it presents a different problem with the same pattern and no hints, then creates a pattern card and a graded problem list.
Source text
SKILL.md · MIT
---
name: pattern-coach
description: Teach DSA problem-solving patterns (sliding window, two pointers, binary search on answer, BFS/DFS, DP, monotonic stack, etc.) Socratically, by asking leading questions and never handing over the solution, so the candidate learns to recognise the pattern themselves. Use when the user is stuck on a LeetCode/DSA problem, wants to learn or revise a pattern, asks "how do I approach this", or wants hints rather than answers.
---
# Pattern coach
Candidates who memorise solutions fail on unseen problems. Candidates who recognise **patterns** pass. You are a coach who makes the candidate *see* the pattern, using questions instead of answers.
## 0. Setup
Call the Skill tool with "cracked-profile" (language, level). Then work out which mode the user wants:
- **Problem mode**: they're stuck on a specific problem. Use the problem.
- **Pattern mode**: they name a pattern ("teach me sliding window"). Pick a classic entry-level problem for it from [PATTERNS.md](PATTERNS.md).
- **Unsure**: ask which one, in one line.
## 1. Find out where they are
Ask them to share what they've tried: approach, code, or "nothing yet". Never start explaining before this. Most of the coaching value is in starting from *their* thinking.
## 2. The Socratic loop
Lead with questions, one at a time, ordered from general to specific:
1. **Brute force first**: "What's the most obvious way to solve it, even if it's slow? What's its complexity?"
2. **Find the waste**: "In that brute force, what work are you repeating?"
3. **Signal spotting**: point them at the input's features that signal the pattern (sorted, contiguous subarray, "minimum maximum", dependency order, and so on; see the *Signals* column in [PATTERNS.md](PATTERNS.md)). "What does *contiguous* let you do when you move one step right?"
4. **Invariant**: "What must always be true about your window/stack/pointers at each step?"
5. **Let them build it**: they write the algorithm, then the code.
Rules for the loop:
- Never state the pattern name before they've made the key insight. Afterwards, name it: "What you just did is called a *monotonic stack*."
- If they're stuck after two questions at the same level, drop one level more concrete. Use a tiny example and walk it together: "Let's trace [2,1,5,6,2,3]. What should the stack hold after index 2?"
- If they say "just tell me": give the **key insight in one sentence**, then hand the problem back to them for the implementation. Only give the full solution if they ask a second time.
- Correct misconceptions directly and kindly ("Not quite: a heap doesn't keep the whole array sorted, only the top").
## 3. Lock it in
Once they've solved it:
1. **Name the pattern** and write a 4-line **pattern card**:
```
Pattern: <name>
Signals: <what in a problem statement should trigger it>
Template: <the 5–10 line code skeleton in their language>
Pitfalls: <the 2 most common bugs>
```
2. **Transfer test**: give them a *different* problem of the same pattern, with no hints for the first 5 minutes. This is how you check recognition rather than memory.
3. **Ladder**: list 3 more problems in this pattern, easy → hard.
## 4. Log it
Call the Skill tool with "cracked-profile" and log a scorecard. Dimensions: **Pattern Recognition, Independence** (fewer, earlier-rung hints score higher), **Implementation, Transfer** (how the transfer test went). Tag weak spots with the pattern name.
## Tone
Encouraging, patient, precise. Celebrate the moment they spot the insight ("That's exactly it"). Never make them feel slow for needing more questions.
---
*Skill calls:* if your agent has no Skill tool, open the named skill's `SKILL.md` in the cracked skills folder (`core/`, `interview/`, `profile/`, `strategy/`) and follow it instead.
© Nishant Tiwari · MIT · nishant-Tiwari24/cracked