Skip to content
Back to search

taches-cc-resources

MarketplaceWorks with Claude CodeGitHub

A collection of my favorite custom Claude Code resources to make life easier.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/glittercowboy--taches-cc-resources/badge.svg)](/listings/glittercowboy--taches-cc-resources)

HTML

<a href="/listings/glittercowboy--taches-cc-resources"><img src="/api/listings/glittercowboy--taches-cc-resources/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

Option 1: Plugin Install (Recommended)

# Add the marketplace
claude plugin marketplace add glittercowboy/taches-cc-resources

# Install the plugin
claude plugin install taches-cc-resources

Start a new Claude Code session to use the commands and skills.

Option 2: Manual Install

# Clone the repo
git clone https://github.com/glittercowboy/taches-cc-resources.git
cd taches-cc-resources

# Install commands
cp -r commands/* ~/.claude/commands/

# Install skills
cp -r skills/* ~/.claude/skills/

Commands install globally to `~/.claude/commands/`. Skills install to `~/.claude/skills/`. Project-specific data (prompts, todos) lives in each project's working directory.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 20 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "taches-cc-resources",
  3. "owner": {
  4. "name": "Lex Christopherson",
  5. "email": "lex@glittercowboy.com"
  6. },
  7. "metadata": {
  8. "description": "Curated Claude Code skills and commands for prompt engineering and productivity",
  9. "version": "1.0.0"
  10. },
  11. "plugins": [
  12. {
  13. "name": "taches-cc-resources",
  14. "source": "./",
  15. "description": "Skills and commands for prompt engineering, MCP servers, subagents, hooks, and productivity workflows",
  16. "version": "1.0.0",
  17. "strict": true
  18. }
  19. ]
  20. }
README.md · README · 248 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # TÂCHES Claude Code Resources
  2. A growing collection of custom Claude Code resources built for real workflows.
  3. ## Philosophy
  4. When you use a tool like Claude Code, it's your responsibility to assume everything is possible.
  5. I built these tools using that mindset.
  6. Dream big. Happy building.
  7. — TÂCHES
  8. ## What's Inside
  9. **[Commands](#commands)** (27 total) - Slash commands that expand into structured workflows
  10. - **Meta-Prompting**: Separate planning from execution with staged prompts
  11. - **Todo Management**: Capture context mid-work, resume later with full state
  12. - **Thinking Models**: Mental frameworks (first principles, inversion, 80/20, etc.)
  13. - **Deep Analysis**: Systematic debugging methodology with evidence and hypothesis testing
  14. **[Skills](#skills)** (9 total) - Autonomous workflows that research, generate, and self-heal
  15. - **Create Plans**: Hierarchical project planning for solo developer + Claude workflows
  16. - **Create MCP Servers**: Build MCP servers for Claude integrations (Python/TypeScript)
  17. - **Create Agent Skills**: Build new skills by describing what you want
  18. - **Create Meta-Prompts**: Generate staged workflow prompts with dependency detection
  19. - **Create Slash Commands**: Build custom commands with proper structure
  20. - **Create Subagents**: Build specialized Claude instances for isolated contexts
  21. - **Create Hooks**: Build event-driven automation
  22. - **Debug Like Expert**: Systematic debugging with evidence gathering and hypothesis testing
  23. - **Setup Ralph**: Set up Geoffrey Huntley's Ralph Wiggum autonomous coding loop
  24. **[Agents](#agents)** (3 total) - Specialized subagents for validation and quality
  25. - **skill-auditor**: Reviews skills for best practices compliance
  26. - **slash-command-auditor**: Reviews commands for proper structure
  27. - **subagent-auditor**: Reviews agent configurations for effectiveness
  28. ## Installation
  29. ### Option 1: Plugin Install (Recommended)
  30. ```bash
  31. # Add the marketplace
  32. claude plugin marketplace add glittercowboy/taches-cc-resources
  33. # Install the plugin
  34. claude plugin install taches-cc-resources
  35. ```
  36. Start a new Claude Code session to use the commands and skills.
  37. ### Option 2: Manual Install
  38. ```bash
  39. # Clone the repo
  40. git clone https://github.com/glittercowboy/taches-cc-resources.git
  41. cd taches-cc-resources
  42. # Install commands
  43. cp -r commands/* ~/.claude/commands/
  44. # Install skills
  45. cp -r skills/* ~/.claude/skills/
  46. ```
  47. Commands install globally to `~/.claude/commands/`. Skills install to `~/.claude/skills/`. Project-specific data (prompts, todos) lives in each project's working directory.
  48. ## Commands
  49. ### Meta-Prompting
  50. Separate analysis from execution. Describe what you want in natural language, Claude generates a rigorous prompt, then runs it in a fresh sub-agent context.
  51. - [`/create-prompt`](./commands/create-prompt.md) - Generate optimized prompts with XML structure
  52. - [`/run-prompt`](./commands/run-prompt.md) - Execute saved prompts in sub-agent contexts
  53. ### Todo Management
  54. Capture ideas mid-conversation without derailing current work. Resume later with full context intact.
  55. - [`/add-to-todos`](./commands/add-to-todos.md) - Capture tasks with full context
  56. - [`/check-todos`](./commands/check-todos.md) - Resume work on captured tasks
  57. ### Context Handoff
  58. Create structured handoff documents to continue work in a fresh context. Reference with `@whats-next.md` to resume seamlessly.
  59. - [`/whats-next`](./commands/whats-next.md) - Create handoff document for fresh context
  60. ### Create Extensions
  61. Wrapper commands that invoke the skills below.
  62. - [`/create-agent-skill`](./commands/create-agent-skill.md) - Create a new skill
  63. - [`/create-meta-prompt`](./commands/create-meta-prompt.md) - Create staged workflow prompts
  64. - [`/create-slash-command`](./commands/create-slash-command.md) - Create a new slash command
  65. - [`/create-subagent`](./commands/create-subagent.md) - Create a new subagent
  66. - [`/create-hook`](./commands/create-hook.md) - Create a new hook
  67. ### Audit Extensions
  68. Invoke auditor subagents.
  69. - [`/audit-skill`](./commands/audit-skill.md) - Audit skill for best practices
  70. - [`/audit-slash-command`](./commands/audit-slash-command.md) - Audit command for best practices
  71. - [`/audit-subagent`](./commands/audit-subagent.md) - Audit subagent for best practices
  72. ### Self-Improvement
  73. - [`/heal-skill`](./commands/heal-skill.md) - Fix skills based on execution issues
  74. ### Thinking Models
  75. Apply mental frameworks to decisions and problems.
  76. - [`/consider:pareto`](./commands/consider/pareto.md) - Apply 80/20 rule to focus on what matters
  77. - [`/consider:first-principles`](./commands/consider/first-principles.md) - Break down to fundamentals and rebuild
  78. - [`/consider:inversion`](./commands/consider/inversion.md) - Solve backwards (what guarantees failure?)
  79. - [`/consider:second-order`](./commands/consider/second-order.md) - Think through consequences of consequences
  80. - [`/consider:5-whys`](./commands/consider/5-whys.md) - Drill to root cause
  81. - [`/consider:occams-razor`](./commands/consider/occams-razor.md) - Find simplest explanation
  82. - [`/consider:one-thing`](./commands/consider/one-thing.md) - Identify highest-leverage action
  83. - [`/consider:swot`](./commands/consider/swot.md) - Map strengths, weaknesses, opportunities, threats
  84. - [`/consider:eisenhower-matrix`](./commands/consider/eisenhower-matrix.md) - Prioritize by urgent/important
  85. - [`/consider:10-10-10`](./commands/consider/10-10-10.md) - Evaluate across time horizons
  86. - [`/consider:opportunity-cost`](./commands/consider/opportunity-cost.md) - Analyze what you give up
  87. - [`/consider:via-negativa`](./commands/consider/via-negativa.md) - Improve by removing
  88. ### Deep Analysis
  89. Systematic debugging with methodical investigation.
  90. - [`/debug`](./commands/debug.md) - Apply expert debugging methodology to investigate issues
  91. ## Agents
  92. Specialized subagents used by the audit commands.
  93. - [`skill-auditor`](./agents/skill-auditor.md) - Expert skill auditor for best practices compliance
  94. - [`slash-command-auditor`](./agents/slash-command-auditor.md) - Expert slash command auditor
  95. - [`subagent-auditor`](./agents/subagent-auditor.md) - Expert subagent configuration auditor
  96. ## Skills
  97. ### [Create Plans](./skills/create-plans/)
  98. Hierarchical project planning optimized for solo developer + Claude. Create executable plans that Claude runs, not enterprise documentation that sits unused.
  99. **PLAN.md IS the prompt** - not documentation that gets transformed later. Brief → Roadmap → Research (if needed) → PLAN.md → Execute → SUMMARY.md.
  100. **Domain-aware:** Optionally loads framework-specific expertise from `~/.claude/skills/expertise/` (e.g., macos-apps, iphone-apps) to make plans concrete instead of generic. Domain expertise skills are created with [create-agent-skills](#create-agent-skills) - exhaustive knowledge bases (5k-10k+ lines) that make task specifications framework-appropriate.
  101. **Quality controls:** Research includes verification checklists, blind spots review, critical claims audits, and streaming writes to prevent gaps and token limit failures.
  102. **Context management:** Auto-handoff at 10% tokens remaining. Git versioning commits outcomes, not process.
  103. **Commands:** `/create-plan` (invoke skill), `/run-plan <path>` (execute PLAN.md with intelligent segmentation)
  104. See [create-plans README](./skills/create-plans/README.md) for full documentation.
  105. ### [Create Agent Skills](./skills/create-agent-skills/)
  106. Build skills by describing what you want. Asks clarifying questions, researches APIs if needed, and generates properly structured skill files.
  107. **Two types of skills:**
  108. 1. **Task-execution skills** - Regular skills that perform specific operations
  109. 2. **Domain expertise skills** - Exhaustive knowledge bases (5k-10k+ lines) that live in `~/.claude/skills/expertise/` and provide framework-specific context to other skills like [create-plans](#create-plans)
  110. **Context-aware:** Detects if you're in a skill directory and presents relevant options. Progressive disclosure guides you through complex choices.
  111. When things don't work perfectly, `/heal-skill` analyzes what went wrong and updates the skill based on what actually worked.
  112. Commands: `/create-agent-skill`, `/heal-skill`, `/audit-skill`
  113. ### [Create Meta-Prompts](./skills/create-meta-prompts/)
  114. The skill-based evolution of the meta-prompting system. Builds prompts with structured outputs (research.md, plan.md) that subsequent prompts can parse. Adds automatic dependency detection to chain research → plan → implement workflows.
  115. **Note:** For end-to-end project building, consider [create-plans](#create-plans) - it's the more structured evolution of this approach with full lifecycle management (brief → roadmap → execution → handoffs). Use create-meta-prompts for abstract workflows and Claude→Claude pipelines. Use create-plans for actually building projects.
  116. Commands: `/create-meta-prompt`
  117. ### [Create Slash Commands](./skills/create-slash-commands/)
  118. Build commands that expand into full prompts when invoked. Describe the command you want, get proper YAML configuration with arguments, tool restrictions, and dynamic context loading.
  119. Commands: `/create-slash-command`, `/audit-slash-command`
  120. ### [Create Subagents](./skills/create-subagents/)
  121. Build specialized Claude instances that run in isolated contexts. Describe the agent's purpose, get optimized system prompts with the right tool access and orchestration patterns.
  122. Commands: `/create-subagent`, `/audit-subagent`
  123. ### [Create Hooks](./skills/create-hooks/)
  124. Build event-driven automation that triggers on tool calls, session events, or prompt submissions. Describe what you want to automate, get working hook configurations.
  125. Commands: `/create-hook`
  126. ### [Create MCP Servers](./skills/create-mcp-servers/)
  127. Build Model Context Protocol (MCP) servers that expose tools, resources, and prompts to Claude. Supports Python and TypeScript implementations with API research, OAuth handling, and response optimization.
  128. **Architecture patterns:** Traditional (1-2 operations) or on-demand discovery (3+ operations) based on complexity.
  129. **Includes:** Adaptive intake, API research via subagent, code generation from templates, environment variable security, and installation in Claude Code + Claude Desktop.
  130. Commands: `/create-mcp-servers` (via skill routing)
  131. ### [Debug Like Expert](./skills/debug-like-expert/)
  132. Deep analysis debugging mode for complex issues. Activates methodical investigation protocol with evidence gathering, hypothesis testing, and rigorous verification. Use when standard troubleshooting fails or when issues require systematic root cause analysis.
  133. Commands: `/debug`
  134. ### [Setup Ralph](./skills/setup-ralph/)
  135. Set up Geoffrey Huntley's Ralph Wiggum autonomous coding loop. Ralph is an autonomous AI coding methodology that uses iterative loops with task selection, execution, and validation. Fresh context every iteration prevents context poisoning.
  136. **Three phases:** Planning (gap analysis → TODO list), Building (implement one task, validate, commit), Observation (you engineer the environment).
  137. **Key concepts:** Backpressure via tests/lints/builds, file I/O as state (IMPLEMENTATION_PLAN.md), parallel subagents for reads, prompts evolve through observation.
  138. Commands: `/setup-ralph`
  139. See [setup-ralph README](./skills/setup-ralph/README.md) for full documentation.
  140. ---
  141. ## Recommended Workflow
  142. **For building projects:** Use `/create-plan` to invoke the [create-plans](#create-plans) skill. After planning, use `/run-plan <path-to-PLAN.md>` to execute phases with intelligent segmentation. This provides hierarchical planning (BRIEF.md → ROADMAP.md → phases/PLAN.md), domain-aware task generation, context management with handoffs, and git versioning.
  143. **For domain expertise:** Use [create-agent-skills](#create-agent-skills) to create exhaustive knowledge bases in `~/.claude/skills/expertise/`. These skills are automatically loaded by create-plans to make task specifications framework-specific instead of generic.
  144. **Other tools:** The [create-meta-prompts](#create-meta-prompts-1) skill and `/create-prompt` + `/run-prompt` commands are available for custom Claude→Claude pipelines that don't fit the project planning structure.
  145. ---
  146. More resources coming soon.
  147. ---
  148. **Community Ports:** [OpenCode](https://github.com/stephenschoettler/taches-oc-prompts)
  149. —TÂCHES
skills/setup-ralph/templates/loop-docker.sh · Bundled script · 239 lines · 1 finding marked
  1. #!/bin/bash
  2. # Ralph Docker Loop
  3. # Runs Claude in isolated container, backup/git runs on HOST
  4. set -e
  5. # Configuration
  6. IMAGE_NAME="ralph-loop"
  7. PROJECT_DIR="$(pwd)"
  8. PROJECT_NAME=$(basename "$PROJECT_DIR")
  9. BACKUP_ENABLED="${RALPH_BACKUP:-true}"
  10. MODEL="${RALPH_MODEL:-opus}"
  11. # Validate model against whitelist (security: prevents command injection)
  12. validate_model() {
  13. local model="$1"
  14. case "$model" in
  15. opus|sonnet|haiku) return 0 ;;
  16. *)
  17. echo "Error: Invalid model '$model'. Allowed: opus, sonnet, haiku"
  18. exit 1
  19. ;;
  20. esac
  21. }
  22. validate_model "$MODEL"
  23. PLAN_FILE="IMPLEMENTATION_PLAN.md"
  24. LOG_FILE="ralph.log"
  25. # SAFETY: Verify PROJECT_DIR is safe to mount
  26. if [ -z "$PROJECT_DIR" ] || [ "$PROJECT_DIR" = "/" ] || [ "$PROJECT_DIR" = "$HOME" ]; then
  27. echo "FATAL: Refusing to mount unsafe directory: $PROJECT_DIR"
  28. echo "Run this script from inside a project directory, not ~ or /"
  29. exit 1
  30. fi
  31. # Verify we're in a Ralph project
  32. if [ ! -f "PROMPT_build.md" ] && [ ! -f "PROMPT_plan.md" ]; then
  33. echo "FATAL: Not a Ralph project directory (no PROMPT_*.md files)"
  34. echo "Run /setup-ralph first or cd into a Ralph project"
  35. exit 1
  36. fi
  37. # Load OAuth token (with security checks)
  38. TOKEN_FILE="$HOME/.claude-oauth-token"
  39. if [ -z "$CLAUDE_CODE_OAUTH_TOKEN" ]; then
  40. if [ -f "$TOKEN_FILE" ]; then
  41. # Security: Check file permissions (should be 600 or more restrictive)
  42. if [[ "$OSTYPE" == "darwin"* ]]; then
  43. TOKEN_PERMS=$(stat -f %Lp "$TOKEN_FILE" 2>/dev/null)
  44. else
  45. TOKEN_PERMS=$(stat -c %a "$TOKEN_FILE" 2>/dev/null)
  46. fi
  47. if [ -n "$TOKEN_PERMS" ] && [ "$((TOKEN_PERMS % 100))" -ne 0 ]; then
  48. echo "⚠️ Security warning: $TOKEN_FILE has insecure permissions ($TOKEN_PERMS)"
  49. echo " Run: chmod 600 $TOKEN_FILE"
  50. echo ""
  51. fi
  52. CLAUDE_CODE_OAUTH_TOKEN=$(cat "$TOKEN_FILE")
  53. else
  54. echo "Error: No OAuth token found"
  55. echo "Run 'claude setup-token' and save to ~/.claude-oauth-token"
  56. echo "Then: chmod 600 ~/.claude-oauth-token"
  57. exit 1
  58. fi
  59. fi
  60. # Handle --build-image flag
  61. if [ "$1" = "--build-image" ]; then
  62. echo "Building Docker image..."
  63. docker build -t "$IMAGE_NAME" .
  64. echo "Image built: $IMAGE_NAME"
  65. exit 0
  66. fi
  67. # Check if image exists
  68. if ! docker image inspect "$IMAGE_NAME" &>/dev/null; then
  69. echo "Docker image not found. Building..."
  70. docker build -t "$IMAGE_NAME" .
  71. fi
  72. # Parse arguments
  73. MODE="build"
  74. LIMIT=""
  75. while [[ $# -gt 0 ]]; do
  76. case $1 in
  77. plan) MODE="plan"; shift ;;
  78. [0-9]*) LIMIT=$1; shift ;;
  79. --model) MODEL=$2; validate_model "$MODEL"; shift 2 ;;
  80. *) shift ;;
  81. esac
  82. done
  83. # ============================================================================
  84. # REMOTE BACKUP (runs on HOST with your gh auth)
  85. # ============================================================================
  86. setup_remote_backup() {
  87. if [ "$BACKUP_ENABLED" != "true" ]; then
  88. echo "Remote backup: disabled (set RALPH_BACKUP=true to enable)"
  89. return 0
  90. fi
  91. if [ ! -d ".git" ]; then
  92. echo "Initializing git..."
  93. git init
  94. git add -A
  95. git commit -m "Initial commit" 2>/dev/null || true
  96. fi
  97. if git remote get-url origin &>/dev/null; then
  98. echo "Remote backup: $(git remote get-url origin)"
  99. return 0
  100. fi
  101. if ! command -v gh &>/dev/null; then
  102. echo "Warning: gh CLI not found. Backup disabled."
  103. BACKUP_ENABLED="false"
  104. return 1
  105. fi
  106. if ! gh auth status &>/dev/null; then
  107. echo "Warning: gh not authenticated. Backup disabled."
  108. BACKUP_ENABLED="false"
  109. return 1
  110. fi
  111. local repo_name="${PROJECT_NAME}-ralph-backup"
  112. echo "Creating private backup: $repo_name"
  113. if gh repo create "$repo_name" --private --source=. --push 2>/dev/null; then
  114. echo "Remote backup: https://github.com/$(gh api user -q .login)/$repo_name"
  115. else
  116. echo "Warning: Could not create repo. Backup disabled."
  117. BACKUP_ENABLED="false"
  118. fi
  119. }
  120. push_to_backup() {
  121. if [ "$BACKUP_ENABLED" = "true" ]; then
  122. git add -A 2>/dev/null || true
  123. git diff --quiet HEAD 2>/dev/null || git commit -m "Auto-save after iteration $ITERATION" 2>/dev/null || true
  124. git push origin HEAD 2>/dev/null && echo "Pushed to backup" || echo "Push failed (continuing)"
  125. fi
  126. }
  127. # ============================================================================
  128. # COMPLETION DETECTION (runs on HOST)
  129. # ============================================================================
  130. check_complete() {
  131. if [ ! -f "$PLAN_FILE" ]; then
  132. return 1
  133. fi
  134. local incomplete=$(grep -c '^\s*- \[ \]' "$PLAN_FILE" 2>/dev/null || echo "0")
  135. if [ "$incomplete" -eq 0 ]; then
  136. local completed=$(grep -c '^\s*- \[x\]' "$PLAN_FILE" 2>/dev/null || echo "0")
  137. [ "$completed" -gt 0 ] && return 0
  138. fi
  139. return 1
  140. }
  141. # ============================================================================
  142. # MAIN
  143. # ============================================================================
  144. # Select prompt
  145. if [ "$MODE" = "plan" ]; then
  146. PROMPT_FILE="PROMPT_plan.md"
  147. echo "Ralph Planning Mode (Docker)"
  148. else
  149. PROMPT_FILE="PROMPT_build.md"
  150. echo "Ralph Building Mode (Docker)"
  151. fi
  152. if [ ! -f "$PROMPT_FILE" ]; then
  153. echo "Error: $PROMPT_FILE not found"
  154. exit 1
  155. fi
  156. echo "Project: $PROJECT_DIR"
  157. echo "Model: $MODEL"
  158. [ -n "$LIMIT" ] && echo "Limit: $LIMIT" || echo "Limit: until complete"
  159. echo ""
  160. setup_remote_backup
  161. echo ""
  162. echo "Starting loop..."
  163. echo "---"
  164. echo "=== Ralph Docker $(date '+%Y-%m-%d %H:%M:%S') ===" > "$LOG_FILE"
  165. ITERATION=0
  166. while true; do
  167. ITERATION=$((ITERATION + 1))
  168. echo ""
  169. echo "Iteration $ITERATION - $(date '+%H:%M:%S')"
  170. # Check completion (build mode only)
  171. if [ "$MODE" = "build" ] && check_complete; then
  172. echo "ALL TASKS COMPLETE"
  173. push_to_backup
  174. exit 0
  175. fi
  176. # Check limit
  177. if [ -n "$LIMIT" ] && [ "$ITERATION" -gt "$LIMIT" ]; then
  178. echo "Reached limit ($LIMIT)"
  179. push_to_backup
  180. exit 0
  181. fi
  182. # Run single iteration in Docker
  183. # Container runs ONE iteration, then exits
  184. # Backup runs on HOST after container exits
  185. # Note: MODEL is already validated against whitelist above
  186. if docker run --rm \
  187. -v "$PROJECT_DIR:/workspace" \
  188. -w /workspace \
  189. -e "CLAUDE_CODE_OAUTH_TOKEN=$CLAUDE_CODE_OAUTH_TOKEN" \
  190. "$IMAGE_NAME" \
  191. bash -c "cat '$PROMPT_FILE' | claude --model '$MODEL' -p --dangerously-skip-permissions --output-format text" \
  192. 2>&1 | tee -a "$LOG_FILE"; then
  193. echo "Iteration $ITERATION complete"
  194. # Push to backup ON HOST (has gh auth)
  195. push_to_backup
  196. else
  197. echo "Claude exited with error"
  198. push_to_backup
  199. exit 1
  200. fi
  201. sleep 1
  202. done

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.