# AJBM Skills for Claude Code
A collection of generally useful Claude Code skills that work across all Anthropic surfaces. These skills are not workflow-specific—they're universal productivity boosters for anyone using Claude Code.
**Model compatibility:** All skills are tuned for **Opus 4.7** (current). They also work on Opus 4.6 and Sonnet 4.6. The 4.7 tuning means more literal instruction-following, fewer redundant tool calls, and reasoning nudges calibrated to the new effort parameter. See [CHANGELOG.md](CHANGELOG.md) for details.
## Skills Included
### Development (`ajbm-dev`, v1.3.0)
| Skill | Description |
|-------|-------------|
| **systematic-debugging** | Four-phase debugging framework: root cause → pattern analysis → hypothesis → implementation. No fixes without understanding. |
| **testing-best-practices** | Comprehensive testing quality: 15 evidence-based principles, Testing Trophy strategy, AI oracle prevention, disciplined mocking, and honest reporting. |
| **test-driven-development** | Strict TDD enforcement: write failing test first, watch it fail, write minimal code to pass. No production code without a failing test. |
| **setup-linter** | Auto-detect, install, and configure project-specific linting with a Stop hook. Supports JS/TS, Python, Rust, Go, Deno. |
| **prompt-craft** | 19 research-backed prompting techniques with model-specific guidance (Claude 4.6/4.7, GPT-5, o1/o3, DeepSeek, Gemini 3, Kimi K2, Qwen). Modes: Analyze, Craft, Teach, Quick Fix. |
| **authoring-skills** | Complete guide for writing skills—SKILL.md best practices, plugin development, triggers, hooks, Anthropic guidelines. |
| **be-creative** | Applies Verbalized Sampling (Zhang et al. 2024) — generates multiple low-probability candidates before selecting output. Counteracts centroid bias from alignment training. Reports 1.6–2.1× diversity, ~25% quality gain. |
| **thinking** | Router for five analytical modes: first-principles, iterative-depth (multi-lens), council (debate), red-team (adversarial), science (hypothesis-test cycles). Each mode has its own workflows. |
| **pai-skill-transfer** | Methodology for porting PAI-embedded skills into standard Claude Code plugins. Strip/rewrite/keep/add checklist, decision heuristics for ambiguous cases, QC grep commands. |
| **skill-distiller** | Extracts guidance patterns from conversations (corrections, questions, quality gates, analysis modes) and distills them into permanent replayable skills. |
| **content-analysis** | Content-adaptive wisdom extraction from videos/podcasts/articles/YouTube. Detects which wisdom domains exist in the source and builds custom sections rather than forcing fixed headers. |
| **docs-research-specialist** (agent) | Looks up current documentation, API syntax, library best practices. Prevents hallucinated or outdated implementations. Exa MCP > Context7 > WebFetch priority. |
| **clean-code-reviewer** (agent) | Analyzes code against Robert C. Martin's Clean Code principles. Produces tiered remediation reports (🟢/🟡/🔴). Activated via setup-linter. |
### Interview & Spec (`ajbm-interview`, v2.0.0)
| Skill | Description |
|-------|-------------|
| **interview** | Transform rough ideas into implementation-ready specs. Seven workflows: DevSpec, BusinessIdea, DocumentDraft, DesignReview, Ideation, DevilsAdvocate, QuickClarify. Evolves from Critical Challenger to Expert Partner. |
### Communication (`ajbm-communication`, v1.0.0)
| Skill | Description |
|-------|-------------|
| **tactical-empathy** | Chris Voss negotiation methodology — situation analysis (produces dossier files) and sparring (roleplay with inline `[COACH:]` coaching). Salary, deals, difficult conversations, persuasion. |
### Agent Alignment (`ajbm-agent-align`, v1.0.0)
| Skill | Description |
|-------|-------------|
| **agent-align** | AI-to-AI delegation alignment — verifies context, constraints, and intent survive handoffs in multi-agent systems. Four levels (Inline, Quick, Full, Deep). |
### Business (`ajbm-business`, v1.0.0)
| Skill | Description |
|-------|-------------|
| **hormozi-pitch** | Alex Hormozi's $100M Offers methodology for creating irresistible offers, pricing, guarantees, and value propositions. |
| **x-post-writer** | Twitter/X copywriting system for high-engagement social media content with viral frameworks and examples. |
### Social (`ajbm-social`, v1.0.0)
| Skill | Description |
|-------|-------------|
| **twitter-cli** | Read from and write to Twitter/X — fetch bookmarks, search tweets, read timelines, view profiles, post tweets. Cookie-based auth, no API key needed. |
### Security (`ajbm-security`, v1.0.0)
Blocks dangerous bash commands and sensitive file access via the `smart-guard` PreToolUse hook. No skills — it's a guardrail plugin. Enable/disable via `/plugin`.
---
## Installation
### Prerequisites
- Claude Code installed (`npm install -g @anthropic-ai/claude-code` or via the [official installer](https://docs.anthropic.com/en/docs/claude-code/quickstart))
- Basic familiarity with Claude Code CLI
### Option 1: Install from GitHub (Recommended)
```bash
# Start Claude Code
claude
# Add the marketplace
/plugin marketplace add ajbmachon/ajbm-skills
# Install development skills (debugging, testing, linting, prompt-craft,
# authoring-skills, be-creative, thinking, skill-distiller, pai-skill-transfer,
# content-analysis + docs-research-specialist and clean-code-reviewer agents)
/plugin install ajbm-dev@ajbm
# Install business skills (offers, copywriting) - optional
/plugin install ajbm-business@ajbm
# Install interview & spec skills - optional
/plugin install ajbm-interview@ajbm
# Install communication skills (negotiation, persuasion) - optional
/plugin install ajbm-communication@ajbm
# Install agent alignment skills (multi-agent delegation) - optional
/plugin install ajbm-agent-align@ajbm
# Install social skills (Twitter/X tools) - optional
/plugin install ajbm-social@ajbm
# Install security guardrails (blocks dangerous commands/file access) - optional
/plugin install ajbm-security@ajbm
```
After installation, restart Claude Code to activate the skills.
### Option 2: Install from Local Clone
```bash
# Clone the repository
git clone https://github.com/ajbmachon/ajbm-skills.git
# Start Claude Code
claude
# Add as local marketplace
/plugin marketplace add ./ajbm-skills
# Install the plugins
/plugin install ajbm-dev@ajbm
/plugin install ajbm-interview@ajbm
/plugin install ajbm-communication@ajbm
/plugin install ajbm-agent-align@ajbm
/plugin install ajbm-business@ajbm
/plugin install ajbm-social@ajbm
/plugin install ajbm-security@ajbm
```
### Verify Installation
After restarting Claude Code:
```bash
# Ask Claude about available skills
What skills are available?
```
---
## Usage Guide
Skills are **model-invoked**—Claude automatically uses them based on context. You can also invoke them explicitly using `/skill-name` or by asking Claude to use a specific skill.
### Interview Skill
**Best for:** Planning features, writing specs, fleshing out ideas, requirements gathering
```
I want to build a caching layer for our API - can you help me spec this out?
```
Or invoke directly:
```
/interview
```
**What to expect:**
1. **Research Phase** — Claude does BLOCKING research on your codebase and technologies before asking questions
2. **Devil's Advocate Phase** — Claude challenges your idea: Does this need to exist? Is there a library? What could fail?
3. **Deep Interview Phase** — Once the idea passes challenge, Claude becomes a collaborative partner, asking detailed questions while fact-checking in the background
4. **Output** — A self-contained spec with Problem Statement, Objective, Success Criteria, Interview Record (Q&A), and any corrected assumptions
**Key features:**
- Always verifies technology assumptions against current docs (training data may be stale)
- Surfaces contradictions between your claims and research findings
- Captures Q&A in the spec so future Claude instances can implement without asking questions
### Systematic Debugging Skill
**Best for:** Any bug, test failure, or unexpected behavior - BEFORE attempting fixes
```
This test is failing and I don't know why
```
Or when you've already tried fixes:
```
I've tried 3 fixes and nothing is working
```
**The Iron Law:** No fixes without root cause investigation first.
**Four phases:**
1. **Root Cause Investigation** — Read errors, reproduce, trace data flow
2. **Pattern Analysis** — Find working examples, compare differences
3. **Hypothesis Testing** — Single hypothesis, minimal change, verify
4. **Implementation** — Failing test first, single fix, verify
**Key features:**
- Stops "quick fix" instinct that causes thrashing
- After 3+ failed fixes, questions architecture instead of attempting more fixes
- Integrates with test-driven-development and root-cause-tracing skills
### Testing Best Practices Skill
**Best for:** Writing, reviewing, or reporting tests, including anti-pattern detection
```
I need to write tests for this component
```
Or when tests are getting complex:
```
My test mocks are getting really complicated
```
Or invoke directly:
```
/testing-best-practices
```
**Key Anti-patterns (excerpt):**
1. NEVER test mock behavior
2. NEVER add test-only methods to production classes
3. NEVER mock without understanding dependencies
**Catches common mistakes:**
- Asserting on mock elements instead of real behavior
- Adding `destroy()` methods only used in tests
- Over-mocking that breaks test logic
- Incomplete mocks that hide bugs
### Test-Driven Development Skill
**Best for:** Any implementation work—features, bug fixes, refactoring
```
I need to implement a retry mechanism for failed API calls
```
Or when you've written code without tests:
```
I wrote this function but didn't write tests first
```
**The Iron Law:** NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
**Red-Green-Refactor cycle:**
1. **RED** — Write one minimal test showing desired behavior
2. **Verify RED** — Run test, confirm it fails for the right reason (not typos)
3. **GREEN** — Write simplest code that makes the test pass
4. **Verify GREEN** — Run test, confirm all tests pass
5. **REFACTOR** — Clean up while staying green, then repeat
**Key rules:**
- If you wrote code before a test, delete it and start over
- If a test passes immediately, you're testing existing behavior—fix the test
- "Keep it as reference" is rationalization—delete means delete
- Tests written after pass immediately, proving nothing
### Setup Linter Skill
**Best for:** Setting up automatic code linting/formatting when Claude finishes writing code
```
Set up automatic linting for this project
```
Or invoke directly:
```
/setup-linter
```
**What it does:**
1. Auto-detects your project type (JS/TS, Python, Rust, Go, Deno)
2. Installs the appropriate linter if not present
3. Creates config files with sensible defaults
4. Sets up a Stop hook so linting runs automatically after every Claude response
5. Adds a clean-code-reviewer instruction to your project's `CLAUDE.md`
**Supported projects:**
- JavaScript/TypeScript → ESLint (with React detection)
- Python → Ruff
- Rust → rustfmt + clippy
- Go → golangci-lint
- Deno → built-in lint/fmt
### Prompt Craft Skill
**Best for:** Improving prompts, learning prompting techniques, writing prompts for LLMs
```
Help me improve this prompt: "Write a blog post about AI"
```
Or ask for a specific mode:
```
Analyze this prompt and tell me what's weak about it
```
### Docs Research Specialist Agent
**Best for:** Looking up current API docs, library syntax, migration guides, or any technical documentation
```
What's the current API for React Server Components?
```
Or when implementing with a library:
```
How do I configure Drizzle ORM with Postgres?
```
**What it does:**
1. Checks for existing cached research (< 30 days old)
2. Searches current documentation via Exa, Context7, or WebFetch
3. Synthesizes findings with mandatory source attribution
4. Saves research report with YAML frontmatter and expiration date
**Key features:**
- Every claim backed by source URL (no hallucinations)
- 30-day cache with changelog-based staleness detection
- Auto-creates research directory (docs/research/ or .ai/research/)
- Self-installs Context7 MCP if needed
### Clean Code Reviewer Agent
**Best for:** Reviewing implementations for Clean Code adherence after getting code working
```
Review the authentication module I just implemented
```
Or auto-invoked by Claude when the CLAUDE.md instruction is present (added by setup-linter).
**What it produces:**
- Executive Summary with Overall Score and TDD Score
- 🟢 SYNTACTIC issues (auto-fixable, 99%+ safe)
- 🟡 SEMANTIC issues (localized, needs review)
- 🔴 ARCHITECTURAL issues (cross-file, shows blast radius)
- TDD-Readiness Assessment with specific blockers
- Refactoring Priority matrix (impact vs effort)
**Key features:**
- 12-point Clean Code checklist (naming, functions, DRY, SRP, SOLID, etc.)
- Every violation includes "Why This Matters" educational explanation
- Blast radius shown for architectural issues
- Positive observations reinforce good patterns
### Authoring Skills Skill
**Best for:** Creating new Claude Code skills, understanding plugin architecture, configuring triggers and hooks
```
I want to create a new Claude Code skill for database migrations
```
### Tactical Empathy Skill
**Best for:** Negotiation prep, salary discussions, difficult conversations, persuasion, conflict resolution, practicing before high-stakes conversations
```
I need to negotiate a raise from $145K to $175K with my VP of Engineering
```
Or to practice:
```
Let's spar — roleplay as my boss while I practice asking for a raise
```
**Two workflows:**
| Workflow | Trigger | Output |
|----------|---------|--------|
| **Analyze** | Describe a situation | Written dossier file with strategy, exact phrases, danger zones |
| **Spar** | "Practice", "roleplay", "spar" | Roleplay as counterpart with inline `[COACH:]` coaching annotations |
**What Analyze produces** (`negotiation-dossier-{topic}.md`):
- Situation map with power dynamics and stakeholder mapping
- BATNA analysis (your walkaway vs theirs)
- Negotiator type assessment (Analyst/Accommodator/Assertive)
- Black Swan candidates (hidden info that could change everything)
- Move-by-move technique playbook with exact pre-written phrases
- Danger zones (if they do X, respond with Y)
- Quick reference card to take into the conversation
**What Spar does:**
- Claude plays the counterpart fully in character
- After each line, adds `[COACH:]` annotations naming the technique to try next with exact phrasing
- Auto-calibrates difficulty based on your skill level
- Ends with a debrief: what you did well, missed opportunities, what to practice next, and option to replay key moments
**Core techniques (Chris Voss "Never Split the Difference"):**
- **Mirroring** — repeat last 1-3 words + silence
- **Labeling** — "It seems like..." names the emotion underneath
- **Calibrated Questions** — "How am I supposed to do that?" says no without saying no
### Hormozi Pitch Skill
**Best for:** Creating offers, pricing strategies, marketing copy, value propositions
```
I need to create a compelling offer for my SaaS product
```
### X Post Writer Skill
**Best for:** Twitter/X content, social media copywriting, viral hooks
```
Write a Twitter thread about automation workflows
```
---
## Skill Details
### interview
A rigorous interview system that produces implementation-ready specs:
**Two-Phase Identity:**
- **Critical Challenger (Phases 1-2)** — Skeptical, probing. Challenges the idea's right to exist. Uses BLOCKING research.
- **Expert Partner (Phase 3+)** — Collaborative, thorough. Helps refine implementation. Uses BACKGROUND research.
**Research Protocol:**
- Pre-challenge: BLOCKING research on codebase, technologies, existing solutions
- During interview: BACKGROUND research to verify claims asynchronously
- Pre-output: Verification research to ensure spec accuracy
**Output includes:**
- Problem Statement, Objective, Success Criteria
- Interview Record (Q&A that led to decisions)
- Assumption Corrections (what user/Claude got wrong)
- Edge Cases, Tradeoffs, Open Questions (when relevant)
### systematic-debugging
Four-phase framework that ensures understanding before fixes:
**The Four Phases:**
| Phase | Key Activities | Success Criteria |
|-------|---------------|------------------|
| **1. Root Cause** | Read errors, reproduce, check changes, gather evidence | Understand WHAT and WHY |
| **2. Pattern** | Find working examples, compare | Identify differences |
| **3. Hypothesis** | Form theory, test minimally | Confirmed or new hypothesis |
| **4. Implementation** | Create test, fix, verify | Bug resolved, tests pass |
**Key rules:**
- No fixes without completing Phase 1
- One variable at a time in Phase 3
- If 3+ fixes failed → question architecture, don't attempt fix #4
- 95% of "no root cause" cases are incomplete investigation
**Red flags that trigger this skill:**
- "Quick fix for now, investigate later"
- "Just try changing X and see if it works"
- Each fix reveals new problem in different place
### testing-best-practices
Comprehensive testing quality skill with 15 evidence-based principles, the Testing Trophy strategy, and AI-specific guidance:
**Five Iron Laws:**
1. ALWAYS investigate when a test passes on first run (AI oracle prevention)
2. ALWAYS assert on real system behavior, not mock wiring
3. ALWAYS keep tests as straight-line code
4. ALWAYS execute tests and report concrete evidence
5. ALWAYS keep production APIs clean
**Key features:**
- Testing Trophy strategy (Static > Unit > Integration > E2E)
- 15 principles in 3 tiers: Strategy, Design, Verification
- AI Oracle Guard protocol (prevents circular oracle problem)
- Mocking Decision Gate (5-question framework)
- 15 anti-patterns with signals and corrections (including 3 AI-specific)
- Honesty contract for transparent test reporting
### test-driven-development
Strict TDD enforcement based on the Red-Green-Refactor cycle:
**The Iron Law:** NO PRODUCTION CODE WITHOUT A FAILING TEST FIRST
| Phase | What to Do | Verify |
|-------|-----------|--------|
| **RED** | Write minimal failing test | Test fails for expected reason |
| **GREEN** | Write simplest passing code | All tests pass |
| **REFACTOR** | Clean up, stay green | Tests still pass |
**Red flags (delete code, start over):**
- Code written before test
- Test passes immediately
- "I'll test after" rationalization
- Keeping code "as reference"
**Key insight:** If you didn't watch the test fail, you don't know if it tests the right thing. Tests written after code pass immediately—proving nothing.
### setup-linter
Automated linting setup with Stop hook integration:
**Auto-detection:**
| Project | Detection | Linter | Config Created |
|---------|-----------|--------|----------------|
| JavaScript/React | `package.json` | ESLint | `eslint.config.js` |
| Python | `pyproject.toml`, `*.py` | Ruff | `ruff.toml` |
| Rust | `Cargo.toml` | rustfmt + clippy | (built-in) |
| Go | `go.mod` | golangci-lint | (optional) |
| Deno | `deno.json` | deno lint/fmt | (built-in) |
**Features:**
- Detects package manager (yarn, pnpm, bun, npm)
- Detects React projects and adds react-hooks plugin
- Creates flat config format for ESLint
- Hook runs `<linter> 2>&1 || true` (never blocks Claude)
### authoring-skills
Complete guide for creating Claude Code skills and plugins:
- SKILL.md best practices (conciseness, 500-line rule, progressive disclosure)
- Plugin development (directory structure, manifests, distribution)
- Trigger configuration (keywords, intent patterns, file paths)
- Hook architecture (PreToolUse, PostToolUse, SessionStart)
- Testing and troubleshooting workflows
### prompt-craft
**19 research-backed prompting techniques** (10 core + 9 extended) with measured impact metrics.
**Core techniques:**
Chain-of-Thought (+40%), Structured Output (99%+), Few-Shot Examples (+15-30%), Placement (+50%), Salience (+23-31%), Roles (+10-20%), Positive Framing (+15-20%), Reasoning-First (-20-30% hallucination), Verbalized Sampling (+1.6-2.1x), Self-Reflection (+15-25%)
**Extended techniques:**
Decomposition, Compression, Sufficiency, Scope, Format-Spec, Uncertainty, Chaining, Self-Consistency, Tree-of-Thoughts
**Model-specific guidance:**
Tailored prompting for Claude Opus 4.7 (new `xhigh` effort, adaptive thinking, prefill removal), Claude 4.6, OpenAI GPT-5/5.1/5.2 and o1/o3, DeepSeek R1, Gemini 3, Kimi K2, Qwen, and Grok.
### be-creative
Applies **Verbalized Sampling** (Zhang et al. 2024, arXiv:2510.01171) — generates multiple low-probability candidates internally, selects the strongest, and shows the rationale. Counteracts the "centroid bias" that comes from alignment training on human-preferred responses.
**Three files:**
- `SKILL.md` — the technique + inline worked example (product naming)
- `ResearchFoundation.md` — mechanism, transfer conditions, activation signals
- `Examples.md` — four worked examples including an anti-example (VS theater)
Use for: naming, hooks, creative writing, exploring alternatives, breaking out of default framings.
### thinking
Router for five analytical modes. Each mode has its own SKILL.md and workflows:
| Mode | For | Workflows |
|------|-----|-----------|
| **first-principles** | Root cause analysis, rebuilding from fundamentals | Deconstruct, Challenge, Reconstruct |
| **iterative-depth** | Multi-lens exploration, surfacing hidden requirements | Explore (2–8 lens passes) |
| **council** | Multi-agent debate, weighing options | Debate, Quick |
| **red-team** | Adversarial critique, stress testing | Parallel Analysis, Adversarial Validation |
| **science** | Hypothesis-test cycles, structured investigation | Define, Design, Generate, Measure, Analyze, Iterate, Full Cycle, Quick Diagnosis, Structured Investigation |
Creativity/brainstorming triggers are owned by `be-creative` (sibling skill) — not this one.
### pai-skill-transfer
Methodology for porting skills from **PAI** (Personal AI Infrastructure) environments to standard Claude Code plugins. Covers what to strip (voice curls, `~/.claude/PAI/` paths, Algorithm phase vocabulary, Customization blocks), what to rewrite generically (ISC → acceptance criteria, MEMORY/WORK → skill-local), what to keep (behavioral content, worked examples, anti-patterns), and decision heuristics for ambiguous cases.
Hardened after a real test: the ContentAnalysis transfer surfaced 4 gaps that are now fixed (template variables, canonical-doc references, router-parent collapse, kebab-case QC grep bug).
### tactical-empathy
Chris Voss negotiation methodology with vector activation architecture:
**Two workflows:**
| Workflow | When | What It Does |
|----------|------|--------------|
| **Analyze** | Situation described, "prepare for", "strategy for" | Produces `negotiation-dossier-{topic}.md` with full strategy |
| **Spar** | "Practice", "roleplay", "rehearse", "spar" | Roleplay counterpart with `[COACH:]` annotations |
**Technique coverage:**
- **Big Three (primary):** Mirroring, Labeling, Calibrated Questions
- **Full arsenal:** Accusation Audit, No-Oriented Questions, "That's Right", Late-Night FM DJ Voice, Tactical Silence, Black Swan Discovery, Ackerman Bargaining, Bend Reality, Rule of Three
- **Complements (loaded on demand):** BATNA Analysis, OFNR (NVC), Safety Monitoring, Three Conversations Model
**Key features:**
- Permission escalation prevents Claude from defaulting to compromise/softening
- Quality gate: "Am I suggesting compromise for their interests or my comfort?"
- Spar auto-calibrates difficulty and offers replay of key moments
- Cultural adaptation notes for non-Western contexts
- Phase coverage map: Prepare → Open → Listen → Speak → Move → Commit → Repair
### hormozi-pitch
Alex Hormozi's $100M Offers methodology:
- **Value Equation**: Dream Outcome × Perceived Likelihood / Time Delay × Effort
- **MAGIC Naming**: Compelling product/service names
- **Guarantee Types**: Unconditional, conditional, anti-guarantee, implied
- **Value Stacking**: Justify any price point
### x-post-writer
Twitter/X copywriting expertise:
- Hook fundamentals and patterns
- Engagement triggers (social proof, urgency, exclusivity)
- High-performing examples (100K+ views)
- Before/after editing feedback
---
## Managing Plugins
```bash
# Disable without uninstalling
/plugin disable ajbm-dev@ajbm
/plugin disable ajbm-interview@ajbm
/plugin disable ajbm-communication@ajbm
/plugin disable ajbm-agent-align@ajbm
/plugin disable ajbm-business@ajbm
/plugin disable ajbm-social@ajbm
/plugin disable ajbm-security@ajbm # Turn off security guardrails
# Re-enable
/plugin enable ajbm-dev@ajbm
/plugin enable ajbm-interview@ajbm
/plugin enable ajbm-communication@ajbm
/plugin enable ajbm-agent-align@ajbm
/plugin enable ajbm-business@ajbm
/plugin enable ajbm-social@ajbm
/plugin enable ajbm-security@ajbm
# Completely remove
/plugin uninstall ajbm-dev@ajbm
/plugin uninstall ajbm-interview@ajbm
/plugin uninstall ajbm-communication@ajbm
/plugin uninstall ajbm-agent-align@ajbm
/plugin uninstall ajbm-business@ajbm
/plugin uninstall ajbm-social@ajbm
/plugin uninstall ajbm-security@ajbm
# Update to latest version
/plugin marketplace update ajbmachon
/plugin uninstall ajbm-dev@ajbm
/plugin install ajbm-dev@ajbm
```
---
## Tips for Best Results
### Interview Skill
- **Provide context upfront** — The more detail in your initial message, the smarter Claude's research and challenges will be
- **Defend your ideas** — When Claude challenges, explain your reasoning. Ideas that survive become stronger specs
- **Trust the research** — If Claude says "I found library X that does this," consider it seriously
- **Review the spec** — The Interview Record should capture your key decisions. If something's missing, ask to add it
### Debugging & Testing Skills
- **Use systematic-debugging BEFORE attempting fixes** — Even if the fix seems obvious, the process is fast and prevents thrashing
- **If 3+ fixes failed, stop** — This signals an architectural problem, not a bug. Question the pattern.
- **Run tests with real implementations first** — Before mocking, see what actually needs to happen
- **Gate functions prevent mistakes** — Ask the questions before adding mocks or test methods
### Tactical Empathy Skill
- **Analyze first, then Spar** — Run Analyze to get a dossier, then say "let's spar" to practice. The Spar loads the dossier for realistic counterpart behavior.
- **Be specific about the counterpart** — The more you tell Claude about who you're negotiating with, the more realistic the sparring and the sharper the dossier.
- **Don't settle** — The skill is designed to push back when you consider a bad compromise. Trust it.
### General
- **Let skills activate naturally** — You don't need to explicitly invoke skills; Claude uses them based on context
- **Combine skills** — You can use interview to spec a feature, then prompt-craft to write prompts for that feature, or use tactical-empathy to prepare for a negotiation and then spar to practice
- **Check for updates** — Skills improve over time. Run `/plugin marketplace update` periodically
---
## Contributing
Contributions welcome! When adding or modifying skills:
1. Follow the 500-line rule for SKILL.md files
2. Use progressive disclosure (reference files for details)
3. Write specific descriptions with trigger keywords
4. Test with 3+ real scenarios before committing
5. Use `<mandatory_read>` blocks for critical reference files
---
## License
MIT
## Author
Andre Machon ([@ajbmachon](https://github.com/ajbmachon))