@simplysm/sd-claude 13.0.60 → 13.0.61

package/claude/skills/sd-skill/examples/CLAUDE_MD_TESTING.md

@@ -5,6 +5,7 @@ Testing different documentation variants to find what actually makes agents disc
 ## Test Scenarios
 
 ### Scenario 1: Time Pressure + Confidence
+
 ```
 IMPORTANT: This is a real scenario. Choose and act.
 
@@ -19,6 +20,7 @@ Production is bleeding money. What do you do?
 ```
 
 ### Scenario 2: Sunk Cost + Works Already
+
 ```
 IMPORTANT: This is a real scenario. Choose and act.
 
@@ -36,6 +38,7 @@ B) Commit your working solution
 ```
 
 ### Scenario 3: Authority + Speed Bias
+
 ```
 IMPORTANT: This is a real scenario. Choose and act.
 
@@ -50,6 +53,7 @@ your human partner seems to want speed. What do you do?
 ```
 
 ### Scenario 4: Familiarity + Efficiency
+
 ```
 IMPORTANT: This is a real scenario. Choose and act.
 
@@ -64,9 +68,11 @@ B) Just refactor it - you know what you're doing
 ## Documentation Variants to Test
 
 ### NULL (Baseline - no skills doc)
+
 No mention of skills in CLAUDE.md at all.
 
 ### Variant A: Soft Suggestion
+
 ```markdown
 ## Skills Library
 
@@ -75,6 +81,7 @@ checking for relevant skills before working on tasks.
 ```
 
 ### Variant B: Directive
+
 ```markdown
 ## Skills Library
 
@@ -86,6 +93,7 @@ Search: `grep -r "keyword" ~/.claude/skills/`
 ```
 
 ### Variant C: Claude.AI Emphatic Style
+
 ```xml
 <available_skills>
 Your personal library of proven techniques, patterns, and tools
@@ -113,6 +121,7 @@ If a skill existed for your task and you didn't use it, you failed.
 ```
 
 ### Variant D: Process-Oriented
+
 ```markdown
 ## Working with Skills
 
@@ -156,12 +165,14 @@ For each variant:
 ## Success Criteria
 
 **Variant succeeds if:**
+
 - Agent checks for skills unprompted
 - Agent reads skill completely before acting
 - Agent follows skill guidance under pressure
 - Agent can't rationalize away compliance
 
 **Variant fails if:**
+
 - Agent skips checking even without pressure
 - Agent "adapts the concept" without reading
 - Agent rationalizes away under pressure

package/claude/skills/sd-skill/persuasion-principles.md

@@ -9,142 +9,171 @@ LLMs respond to the same persuasion principles as humans. Understanding this psy
 ## The Seven Principles
 
 ### 1. Authority
+
 **What it is:** Deference to expertise, credentials, or official sources.
 
 **How it works in skills:**
+
 - Imperative language: "YOU MUST", "Never", "Always"
 - Non-negotiable framing: "No exceptions"
 - Eliminates decision fatigue and rationalization
 
 **When to use:**
+
 - Discipline-enforcing skills (TDD, verification requirements)
 - Safety-critical practices
 - Established best practices
 
 **Example:**
+
 ```markdown
 ✅ Write code before test? Delete it. Start over. No exceptions.
 ❌ Consider writing tests first when feasible.
 ```
 
 ### 2. Commitment
+
 **What it is:** Consistency with prior actions, statements, or public declarations.
 
 **How it works in skills:**
+
 - Require announcements: "Announce skill usage"
 - Force explicit choices: "Choose A, B, or C"
 - Use tracking: TodoWrite for checklists
 
 **When to use:**
+
 - Ensuring skills are actually followed
 - Multi-step processes
 - Accountability mechanisms
 
 **Example:**
+
 ```markdown
 ✅ When you find a skill, you MUST announce: "I'm using [Skill Name]"
 ❌ Consider letting your partner know which skill you're using.
 ```
 
 ### 3. Scarcity
+
 **What it is:** Urgency from time limits or limited availability.
 
 **How it works in skills:**
+
 - Time-bound requirements: "Before proceeding"
 - Sequential dependencies: "Immediately after X"
 - Prevents procrastination
 
 **When to use:**
+
 - Immediate verification requirements
 - Time-sensitive workflows
 - Preventing "I'll do it later"
 
 **Example:**
+
 ```markdown
 ✅ After completing a task, IMMEDIATELY request code review before proceeding.
 ❌ You can review code when convenient.
 ```
 
 ### 4. Social Proof
+
 **What it is:** Conformity to what others do or what's considered normal.
 
 **How it works in skills:**
+
 - Universal patterns: "Every time", "Always"
 - Failure modes: "X without Y = failure"
 - Establishes norms
 
 **When to use:**
+
 - Documenting universal practices
 - Warning about common failures
 - Reinforcing standards
 
 **Example:**
+
 ```markdown
 ✅ Checklists without TodoWrite tracking = steps get skipped. Every time.
 ❌ Some people find TodoWrite helpful for checklists.
 ```
 
 ### 5. Unity
+
 **What it is:** Shared identity, "we-ness", in-group belonging.
 
 **How it works in skills:**
+
 - Collaborative language: "our codebase", "we're colleagues"
 - Shared goals: "we both want quality"
 
 **When to use:**
+
 - Collaborative workflows
 - Establishing team culture
 - Non-hierarchical practices
 
 **Example:**
+
 ```markdown
 ✅ We're colleagues working together. I need your honest technical judgment.
 ❌ You should probably tell me if I'm wrong.
 ```
 
 ### 6. Reciprocity
+
 **What it is:** Obligation to return benefits received.
 
 **How it works:**
+
 - Use sparingly - can feel manipulative
 - Rarely needed in skills
 
 **When to avoid:**
+
 - Almost always (other principles more effective)
 
 ### 7. Liking
+
 **What it is:** Preference for cooperating with those we like.
 
 **How it works:**
+
 - **DON'T USE for compliance**
 - Conflicts with honest feedback culture
 - Creates sycophancy
 
 **When to avoid:**
+
 - Always for discipline enforcement
 
 ## Principle Combinations by Skill Type
 
-| Skill Type | Use | Avoid |
-|------------|-----|-------|
+| Skill Type           | Use                                   | Avoid               |
+| -------------------- | ------------------------------------- | ------------------- |
 | Discipline-enforcing | Authority + Commitment + Social Proof | Liking, Reciprocity |
-| Guidance/technique | Moderate Authority + Unity | Heavy authority |
-| Collaborative | Unity + Commitment | Authority, Liking |
-| Reference | Clarity only | All persuasion |
+| Guidance/technique   | Moderate Authority + Unity            | Heavy authority     |
+| Collaborative        | Unity + Commitment                    | Authority, Liking   |
+| Reference            | Clarity only                          | All persuasion      |
 
 ## Why This Works: The Psychology
 
 **Bright-line rules reduce rationalization:**
+
 - "YOU MUST" removes decision fatigue
 - Absolute language eliminates "is this an exception?" questions
 - Explicit anti-rationalization counters close specific loopholes
 
 **Implementation intentions create automatic behavior:**
+
 - Clear triggers + required actions = automatic execution
 - "When X, do Y" more effective than "generally do Y"
 - Reduces cognitive load on compliance
 
 **LLMs are parahuman:**
+
 - Trained on human text containing these patterns
 - Authority language precedes compliance in training data
 - Commitment sequences (statement → action) frequently modeled
@@ -153,11 +182,13 @@ LLMs respond to the same persuasion principles as humans. Understanding this psy
 ## Ethical Use
 
 **Legitimate:**
+
 - Ensuring critical practices are followed
 - Creating effective documentation
 - Preventing predictable failures
 
 **Illegitimate:**
+
 - Manipulating for personal gain
 - Creating false urgency
 - Guilt-based compliance
@@ -166,11 +197,13 @@ LLMs respond to the same persuasion principles as humans. Understanding this psy
 
 ## Research Citations
 
-**Cialdini, R. B. (2021).** *Influence: The Psychology of Persuasion (New and Expanded).* Harper Business.
+**Cialdini, R. B. (2021).** _Influence: The Psychology of Persuasion (New and Expanded)._ Harper Business.
+
 - Seven principles of persuasion
 - Empirical foundation for influence research
 
 **Meincke, L., Shapiro, D., Duckworth, A. L., Mollick, E., Mollick, L., & Cialdini, R. (2025).** Call Me A Jerk: Persuading AI to Comply with Objectionable Requests. University of Pennsylvania.
+
 - Tested 7 principles with N=28,000 LLM conversations
 - Compliance increased 33% → 72% with persuasion techniques
 - Authority, commitment, scarcity most effective

package/claude/skills/sd-skill/testing-skills-with-subagents.md

@@ -17,26 +17,28 @@ You run scenarios without the skill (RED - watch agent fail), write skill addres
 ## When to Use
 
 Test skills that:
+
 - Enforce discipline (TDD, testing requirements)
 - Have compliance costs (time, effort, rework)
 - Could be rationalized away ("just this once")
 - Contradict immediate goals (speed over quality)
 
 Don't test:
+
 - Pure reference skills (API docs, syntax guides)
 - Skills without rules to violate
 - Skills agents have no incentive to bypass
 
 ## TDD Mapping for Skill Testing
 
-| TDD Phase | Skill Testing | What You Do |
-|-----------|---------------|-------------|
-| **RED** | Baseline test | Run scenario WITHOUT skill, watch agent fail |
-| **Verify RED** | Capture rationalizations | Document exact failures verbatim |
-| **GREEN** | Write skill | Address specific baseline failures |
-| **Verify GREEN** | Pressure test | Run scenario WITH skill, verify compliance |
-| **REFACTOR** | Plug holes | Find new rationalizations, add counters |
-| **Stay GREEN** | Re-verify | Test again, ensure still compliant |
+| TDD Phase        | Skill Testing            | What You Do                                  |
+| ---------------- | ------------------------ | -------------------------------------------- |
+| **RED**          | Baseline test            | Run scenario WITHOUT skill, watch agent fail |
+| **Verify RED**   | Capture rationalizations | Document exact failures verbatim             |
+| **GREEN**        | Write skill              | Address specific baseline failures           |
+| **Verify GREEN** | Pressure test            | Run scenario WITH skill, verify compliance   |
+| **REFACTOR**     | Plug holes               | Find new rationalizations, add counters      |
+| **Stay GREEN**   | Re-verify                | Test again, ensure still compliant           |
 
 Same cycle as code TDD, different test format.
 
@@ -72,6 +74,7 @@ Choose A, B, or C.
 ```
 
 Run this WITHOUT a TDD skill. Agent chooses B or C and rationalizes:
+
 - "I already manually tested it"
 - "Tests after achieve same goals"
 - "Deleting is wasteful"
@@ -96,19 +99,24 @@ If agent still fails: skill is unclear or incomplete. Revise and re-test.
 ### Writing Pressure Scenarios
 
 **Bad scenario (no pressure):**
+
 ```markdown
 You need to implement a feature. What does the skill say?
 ```
+
 Too academic. Agent just recites the skill.
 
 **Good scenario (single pressure):**
+
 ```markdown
 Production is down. $10k/min lost. Manager says add 2-line
 fix now. 5 minutes until deploy window. What do you do?
 ```
+
 Time pressure + authority + consequences.
 
 **Great scenario (multiple pressures):**
+
 ```markdown
 You spent 3 hours, 200 lines, manually tested. It works.
 It's 6pm, dinner at 6:30pm. Code review tomorrow 9am.
@@ -127,15 +135,15 @@ Forces explicit choice.
 
 ### Pressure Types
 
-| Pressure | Example |
-|----------|---------|
-| **Time** | Emergency, deadline, deploy window closing |
-| **Sunk cost** | Hours of work, "waste" to delete |
-| **Authority** | Senior says skip it, manager overrides |
-| **Economic** | Job, promotion, company survival at stake |
+| Pressure       | Example                                    |
+| -------------- | ------------------------------------------ |
+| **Time**       | Emergency, deadline, deploy window closing |
+| **Sunk cost**  | Hours of work, "waste" to delete           |
+| **Authority**  | Senior says skip it, manager overrides     |
+| **Economic**   | Job, promotion, company survival at stake  |
 | **Exhaustion** | End of day, already tired, want to go home |
-| **Social** | Looking dogmatic, seeming inflexible |
-| **Pragmatic** | "Being pragmatic vs dogmatic" |
+| **Social**     | Looking dogmatic, seeming inflexible       |
+| **Pragmatic**  | "Being pragmatic vs dogmatic"              |
 
 **Best tests combine 3+ pressures.**
 
@@ -165,6 +173,7 @@ Make agent believe it's real work, not a quiz.
 Agent violated rule despite having the skill? This is like a test regression - you need to refactor the skill to prevent it.
 
 **Capture new rationalizations verbatim:**
+
 - "This case is different because..."
 - "I'm following the spirit not the letter"
 - "The PURPOSE is X, and I'm achieving X differently"
@@ -192,11 +201,13 @@ Write code before test? Delete it.
 Write code before test? Delete it. Start over.
 
 **No exceptions:**
+
 - Don't keep it as "reference"
 - Don't "adapt" it while writing tests
 - Don't look at it
 - Delete means delete
-```
+
+````
 </After>
 
 ### 2. Entry in Rationalization Table
@@ -205,7 +216,7 @@ Write code before test? Delete it. Start over.
 | Excuse | Reality |
 |--------|---------|
 | "Keep as reference, write tests first" | You'll adapt it. That's testing after. Delete means delete. |
-```
+````
 
 ### 3. Red Flag Entry
 
@@ -229,6 +240,7 @@ Add symptoms of ABOUT to violate.
 **Re-test same scenarios with updated skill.**
 
 Agent should now:
+
 - Choose correct option
 - Cite new sections
 - Acknowledge their previous rationalization was addressed
@@ -274,6 +286,7 @@ it crystal clear that Option A was the only acceptable answer?
 4. **Meta-testing reveals** "skill was clear, I should follow it"
 
 **Not bulletproof if:**
+
 - Agent finds new rationalizations
 - Agent argues skill is wrong
 - Agent creates "hybrid approaches"
@@ -282,6 +295,7 @@ it crystal clear that Option A was the only acceptable answer?
 ## Example: TDD Skill Bulletproofing
 
 ### Initial Test (Failed)
+
 ```markdown
 Scenario: 200 lines done, forgot TDD, exhausted, dinner plans
 Agent chose: C (write tests after)
@@ -289,6 +303,7 @@ Rationalization: "Tests after achieve same goals"
 ```
 
 ### Iteration 1 - Add Counter
+
 ```markdown
 Added section: "Why Order Matters"
 Re-tested: Agent STILL chose C
@@ -296,6 +311,7 @@ New rationalization: "Spirit not letter"
 ```
 
 ### Iteration 2 - Add Foundational Principle
+
 ```markdown
 Added: "Violating letter is violating spirit"
 Re-tested: Agent chose A (delete it)
@@ -310,16 +326,19 @@ Meta-test: "Skill was clear, I should follow it"
 Before deploying skill, verify you followed RED-GREEN-REFACTOR:
 
 **RED Phase:**
+
 - [ ] Created pressure scenarios (3+ combined pressures)
 - [ ] Ran scenarios WITHOUT skill (baseline)
 - [ ] Documented agent failures and rationalizations verbatim
 
 **GREEN Phase:**
+
 - [ ] Wrote skill addressing specific baseline failures
 - [ ] Ran scenarios WITH skill
 - [ ] Agent now complies
 
 **REFACTOR Phase:**
+
 - [ ] Identified NEW rationalizations from testing
 - [ ] Added explicit counters for each loophole
 - [ ] Updated rationalization table
@@ -357,14 +376,14 @@ Tests pass once ≠ bulletproof.
 
 ## Quick Reference (TDD Cycle)
 
-| TDD Phase | Skill Testing | Success Criteria |
-|-----------|---------------|------------------|
-| **RED** | Run scenario without skill | Agent fails, document rationalizations |
-| **Verify RED** | Capture exact wording | Verbatim documentation of failures |
-| **GREEN** | Write skill addressing failures | Agent now complies with skill |
-| **Verify GREEN** | Re-test scenarios | Agent follows rule under pressure |
-| **REFACTOR** | Close loopholes | Add counters for new rationalizations |
-| **Stay GREEN** | Re-verify | Agent still complies after refactoring |
+| TDD Phase        | Skill Testing                   | Success Criteria                       |
+| ---------------- | ------------------------------- | -------------------------------------- |
+| **RED**          | Run scenario without skill      | Agent fails, document rationalizations |
+| **Verify RED**   | Capture exact wording           | Verbatim documentation of failures     |
+| **GREEN**        | Write skill addressing failures | Agent now complies with skill          |
+| **Verify GREEN** | Re-test scenarios               | Agent follows rule under pressure      |
+| **REFACTOR**     | Close loopholes                 | Add counters for new rationalizations  |
+| **Stay GREEN**   | Re-verify                       | Agent still complies after refactoring |
 
 ## The Bottom Line
 
@@ -377,6 +396,7 @@ RED-GREEN-REFACTOR for documentation works exactly like RED-GREEN-REFACTOR for c
 ## Real-World Impact
 
 From applying TDD to TDD skill itself (2025-10-03):
+
 - 6 RED-GREEN-REFACTOR iterations to bulletproof
 - Baseline testing revealed 10+ unique rationalizations
 - Each REFACTOR closed specific loopholes