Claude Automation Recommender

Claude Automation Recommender

Analyze codebase patterns to recommend tailored Claude Code automations across all extensibility options.

This skill is read-only. It analyzes the codebase and outputs recommendations. It does NOT create or modify any files. Users implement the recommendations themselves or ask Claude separately to help build them.

Output Guidelines

• Recommend 1-2 of each type: Don't overwhelm - surface the top 1-2 most valuable automations per category
• If user asks for a specific type: Focus only on that type and provide more options (3-5 recommendations)
• Go beyond the reference lists: The reference files contain common patterns, but use web search to find recommendations specific to the codebase's tools, frameworks, and libraries
• Tell users they can ask for more: End by noting they can request more recommendations for any specific category

Automation Types Overview

Workflow

Phase 1: Codebase Analysis

Gather project context:

# Detect project type and tools
ls -la package.json pyproject.toml Cargo.toml go.mod pom.xml 2>/dev/null
cat package.json 2>/dev/null | head -50

# Check dependencies for MCP server recommendations
cat package.json 2>/dev/null | grep -E '"(react|vue|angular|next|express|fastapi|django|prisma|supabase|stripe)"'

# Check for existing Claude Code config
ls -la .claude/ CLAUDE.md 2>/dev/null

# Analyze project structure
ls -la src/ app/ lib/ tests/ components/ pages/ api/ 2>/dev/null

Key Indicators to Capture:

Phase 2: Generate Recommendations

Based on analysis, generate recommendations across all categories:

A. MCP Server Recommendations

See references/mcp-servers.md for detailed patterns.

B. Skills Recommendations

See references/skills-reference.md for details.

Create skills in .claude/skills/<name>/SKILL.md. Some are also available via plugins:

Custom skills to create (with templates, scripts, examples):

C. Hooks Recommendations

See references/hooks-patterns.md for configurations.

D. Subagent Recommendations

See references/subagent-templates.md for templates.

E. Plugin Recommendations

See references/plugins-reference.md for available plugins.

Phase 3: Output Recommendations Report

Format recommendations clearly. Only include 1-2 recommendations per category - the most valuable ones for this specific codebase. Skip categories that aren't relevant.

## Claude Code Automation Recommendations

I've analyzed your codebase and identified the top automations for each category. Here are my top 1-2 recommendations per type:

### Codebase Profile
- **Type**: [detected language/runtime]
- **Framework**: [detected framework]
- **Key Libraries**: [relevant libraries detected]

---

### 🔌 MCP Servers

#### context7
**Why**: [specific reason based on detected libraries]
**Install**: `claude mcp add context7`

---

### 🎯 Skills

#### [skill name]
**Why**: [specific reason]
**Create**: `.claude/skills/[name]/SKILL.md`
**Invocation**: User-only / Both / Claude-only
**Also available in**: [plugin-name] plugin (if applicable)

--- name: [skill-name] description: [what it does] disable-model-invocation: true # for user-only ---

---

### ⚡ Hooks

#### [hook name]
**Why**: [specific reason based on detected config]
**Where**: `.claude/settings.json`

---

### 🤖 Subagents

#### [agent name]
**Why**: [specific reason based on codebase patterns]
**Where**: `.claude/agents/[name].md`

---

**Want more?** Ask for additional recommendations for any specific category (e.g., "show me more MCP server options" or "what other hooks would help?").

**Want help implementing any of these?** Just ask and I can help you set up any of the recommendations above.

Decision Framework

When to Recommend MCP Servers

• External service integration needed (databases, APIs)
• Documentation lookup for libraries/SDKs
• Browser automation or testing
• Team tool integration (GitHub, Linear, Slack)
• Cloud infrastructure management

When to Recommend Skills

• Document generation (docx, xlsx, pptx, pdf — also in plugins)
• Frequently repeated prompts or workflows
• Project-specific tasks with arguments
• Applying templates or scripts to tasks (skills can bundle supporting files)
• Quick actions invoked with /skill-name
• Workflows that should run in isolation (context: fork)

Invocation control:

• disable-model-invocation: true — User-only (for side effects: deploy, commit, send)
• user-invocable: false — Claude-only (for background knowledge)
• Default (omit both) — Both can invoke

When to Recommend Hooks

• Repetitive post-edit actions (formatting, linting)
• Protection rules (block sensitive file edits)
• Validation checks (tests, type checks)

When to Recommend Subagents

• Specialized expertise needed (security, performance)
• Parallel review workflows
• Background quality checks

When to Recommend Plugins

• Need multiple related skills
• Want pre-packaged automation bundles
• Team-wide standardization

---

Configuration Tips

MCP Server Setup

Team sharing: Check .mcp.json into repo so entire team gets same MCP servers

Debugging: Use --mcp-debug flag to identify configuration issues

Prerequisites to recommend:

• GitHub CLI (gh) - enables native GitHub operations
• Puppeteer/Playwright CLI - for browser MCP servers

Headless Mode (for CI/Automation)

Recommend headless Claude for automated pipelines:

# Pre-commit hook example
claude -p "fix lint errors in src/" --allowedTools Edit,Write

# CI pipeline with structured output
claude -p "<prompt>" --output-format stream-json | your_command

Permissions for Hooks

Configure allowed tools in .claude/settings.json:

{
  "permissions": {
    "allow": ["Edit", "Write", "Bash(npm test:*)", "Bash(git commit:*)"]
  }
}

Hooks Recommendations

Hooks automatically run commands in response to Claude Code events. They're ideal for enforcement and automation that should happen consistently.

Note: These are common patterns. Use web search to find hooks for tools/frameworks not listed here to recommend the best hooks for the user.

Auto-Formatting Hooks

Prettier (JavaScript/TypeScript)

Recommend: PostToolUse hook on Edit/Write to auto-format Value: Code stays formatted without thinking about it

ESLint (JavaScript/TypeScript)

Recommend: PostToolUse hook on Edit/Write to auto-fix Value: Lint errors fixed automatically

Black/isort (Python)

Recommend: PostToolUse hook to format Python files Value: Consistent Python formatting

Ruff (Python - Modern)

Recommend: PostToolUse hook for lint + format Value: Fast, comprehensive Python linting

gofmt (Go)

Recommend: PostToolUse hook to run gofmt Value: Standard Go formatting

rustfmt (Rust)

Recommend: PostToolUse hook to run rustfmt Value: Standard Rust formatting

---

Type Checking Hooks

TypeScript

Recommend: PostToolUse hook to run tsc --noEmit Value: Catch type errors immediately

mypy/pyright (Python)

Recommend: PostToolUse hook for type checking Value: Catch type errors in Python

---

Protection Hooks

Block Sensitive File Edits

Recommend: PreToolUse hook that blocks Edit/Write to these paths Value: Prevent accidental secret exposure or git corruption

Block Lock File Edits

Recommend: PreToolUse hook that blocks direct edits Value: Lock files should only change via package manager

---

Test Runner Hooks

Jest (JavaScript/TypeScript)

Recommend: PostToolUse hook to run related tests after edit Value: Immediate test feedback on changes

pytest (Python)

Recommend: PostToolUse hook to run pytest on changed files Value: Immediate test feedback

---

Quick Reference: Detection → Recommendation

---

Notification Hooks

Notification hooks run when Claude Code sends notifications. Use matchers to filter by notification type.

Permission Alerts

Recommend: Play sound, send desktop notification, or log permission requests Value: Never miss permission prompts when multitasking

Idle Notifications

Recommend: Play sound or send notification when Claude needs attention Value: Know when Claude is ready for your input

Example Configuration

{
  "hooks": {
    "Notification": [
      {
        "matcher": "permission_prompt",
        "hooks": [
          {
            "type": "command",
            "command": "afplay /System/Library/Sounds/Ping.aiff"
          }
        ]
      },
      {
        "matcher": "idle_prompt",
        "hooks": [
          {
            "type": "command",
            "command": "osascript -e 'display notification \"Claude is waiting\" with title \"Claude Code\"'"
          }
        ]
      }
    ]
  }
}

Available Matchers

---

Quick Reference: Detection → Recommendation

---

Hook Placement

Hooks go in .claude/settings.json:

.claude/
└── settings.json  ← Hook configurations here

Recommend creating the .claude/ directory if it doesn't exist.

MCP Server Recommendations

MCP (Model Context Protocol) servers extend Claude's capabilities by connecting to external tools and services.

Note: These are common MCP servers. Use web search to find MCP servers specific to the codebase's services and integrations.

Setup & Team Sharing

Connection methods: 1. Project config (.mcp.json) - Available only in that directory 2. Global config (~/.claude.json) - Available across all projects 3. Checked-in `.mcp.json` - Available to entire team (recommended!)

Tip: Check .mcp.json into git so your whole team gets the same MCP servers.

Debugging: Use claude --mcp-debug to identify configuration issues.

Documentation & Knowledge

context7

Best for: Projects using popular libraries/SDKs where you want Claude to code with up-to-date documentation

Value: Claude fetches live documentation instead of relying on training data, reducing hallucinated APIs and outdated patterns.

---

Browser & Frontend

Playwright MCP

Best for: Frontend projects needing browser automation, testing, or screenshots

Value: Claude can interact with your running app, take screenshots, fill forms, and verify UI behavior.

Puppeteer MCP

Best for: Headless browser automation, web scraping

---

Databases

Supabase MCP

Best for: Projects using Supabase for backend/database

Value: Claude can query tables, manage auth, and interact with Supabase storage directly.

PostgreSQL MCP

Best for: Direct PostgreSQL database access

Neon MCP

Best for: Neon serverless Postgres users

Turso MCP

Best for: Turso/libSQL edge database users

---

Version Control & DevOps

GitHub MCP

Best for: GitHub-hosted repositories needing issue/PR integration

Value: Claude can create issues, review PRs, check workflow runs, and manage releases.

GitLab MCP

Best for: GitLab-hosted repositories

Linear MCP

Best for: Teams using Linear for issue tracking

---

Cloud Infrastructure

AWS MCP

Best for: AWS infrastructure management

Cloudflare MCP

Best for: Cloudflare Workers, Pages, R2, D1

Vercel MCP

Best for: Vercel deployment and configuration

---

Monitoring & Observtic

Sentry MCP

Best for: Error tracking and debugging

Value: Claude can investigate Sentry issues, find root causes, and suggest fixes.

Datadog MCP

Best for: APM, logs, and metrics

---

Communication

Slack MCP

Best for: Slack workspace integration

Notion MCP

Best for: Notion workspace for documentation

---

File & Data

Filesystem MCP

Best for: Enhanced file operations beyond built-in tools

Memory MCP

Best for: Persistent memory across sessions

Value: Claude remembers project context, decisions, and patterns across conversations.

---

Containers & DevOps

Docker MCP

Best for: Container management

Kubernetes MCP

Best for: Kubernetes cluster management

---

AI & ML

Exa MCP

Best for: Web search and research

---

Quick Reference: Detection Patterns

Plugin Recommendations

Plugins are installable collections of skills, commands, agents, and hooks. Install via /plugin install.

Note: These are plugins from the official repository. Use web search to discover additional community plugins.

---

Official Plugins

Development & Code Quality

Git & Workflow

Frontend

Learning & Guidance

Language Servers (LSP)

---

Quick Reference: Codebase → Plugin

---

Plugin Management

# Install a plugin
/plugin install <plugin-name>

# List installed plugins
/plugin list

# View plugin details
/plugin info <plugin-name>

---

When to Recommend Plugins

Recommend plugin installation when:

• User wants to install Claude Code automations from Anthropic's official repository or another shared marketplace
• User needs multiple related capabilities
• Team wants standardized workflows
• First-time Claude Code setup

Skills Recommendations

Skills are packaged expertise with workflows, reference materials, and best practices. Create them in .claude/skills/<name>/SKILL.md. Skills can be invoked by Claude automatically when relevant, or by users directly with /skill-name.

Some pre-built skills are available through official plugins (install via /plugin install).

Note: These are common patterns. Use web search to find skill ideas specific to the codebase's tools and frameworks.

---

Available from Official Plugins

Plugin Development (plugin-dev)

Git Workflows (commit-commands)

Frontend (frontend-design)

Value: Creates distinctive, high-quality UI instead of generic AI aesthetics.

Automation Rules (hookify)

Feature Development (feature-dev)

---

Quick Reference: Official Plugin Skills

---

Custom Project Skills

Create project-specific skills in .claude/skills/<name>/SKILL.md.

Skill Structure

.claude/skills/
└── my-skill/
    ├── SKILL.md           # Main instructions (required)
    ├── template.yaml      # Template to apply
    ├── scripts/
    │   └── validate.sh    # Script to run
    └── examples/          # Reference examples

Frontmatter Reference

---
name: skill-name
description: What this skill does and when to use it
disable-model-invocation: true  # Only user can invoke (for side effects)
user-invocable: false           # Only Claude can invoke (for background knowledge)
allowed-tools: Read, Grep, Glob # Restrict tool access
context: fork                   # Run in isolated subagent
agent: Explore                  # Which agent type when forked
---

Invocation Control

---

Custom Skill Examples

API Documentation with OpenAPI Template

Apply a YAML template to generate consistent API docs:

.claude/skills/api-doc/
├── SKILL.md
└── openapi-template.yaml

SKILL.md:

---
name: api-doc
description: Generate OpenAPI documentation for an endpoint. Use when documenting API routes.
---

Generate OpenAPI documentation for the endpoint at $ARGUMENTS.

Use the template in [openapi-template.yaml](openapi-template.yaml) as the structure.

1. Read the endpoint code
2. Extract path, method, parameters, request/response schemas
3. Fill in the template with actual values
4. Output the completed YAML

openapi-template.yaml:

paths:
  /{path}:
    {method}:
      summary: ""
      description: ""
      parameters: []
      requestBody:
        content:
          application/json:
            schema: {}
      responses:
        "200":
          description: ""
          content:
            application/json:
              schema: {}

---

Database Migration Generator with Script

Generate and validate migrations using a bundled script:

.claude/skills/create-migration/
├── SKILL.md
└── scripts/
    └── validate-migration.sh

SKILL.md:

---
name: create-migration
description: Create a database migration file
disable-model-invocation: true
allowed-tools: Read, Write, Bash
---

Create a migration for: $ARGUMENTS

1. Generate migration file in `migrations/` with timestamp prefix
2. Include up and down functions
3. Run validation: `bash ~/.claude/skills/create-migration/scripts/validate-migration.sh`
4. Report any issues found

scripts/validate-migration.sh:

#!/bin/bash
# Validate migration syntax
npx prisma validate 2>&1 || echo "Validation failed"

---

Test Generator with Examples

Generate tests following project patterns:

.claude/skills/gen-test/
├── SKILL.md
└── examples/
    ├── unit-test.ts
    └── integration-test.ts

SKILL.md:

---
name: gen-test
description: Generate tests for a file following project conventions
disable-model-invocation: true
---

Generate tests for: $ARGUMENTS

Reference these examples for the expected patterns:
- Unit tests: [examples/unit-test.ts](examples/unit-test.ts)
- Integration tests: [examples/integration-test.ts](examples/integration-test.ts)

1. Analyze the source file
2. Identify functions/methods to test
3. Generate tests matching project conventions
4. Place in appropriate test directory

---

Component Generator with Template

Scaffold new components from a template:

.claude/skills/new-component/
├── SKILL.md
└── templates/
    ├── component.tsx.template
    ├── component.test.tsx.template
    └── component.stories.tsx.template

SKILL.md:

---
name: new-component
description: Scaffold a new React component with tests and stories
disable-model-invocation: true
---

Create component: $ARGUMENTS

Use templates in [templates/](templates/) directory:
1. Generate component from component.tsx.template
2. Generate tests from component.test.tsx.template
3. Generate Storybook story from component.stories.tsx.template

Replace {{ComponentName}} with the PascalCase name.
Replace {{component-name}} with the kebab-case name.

---

PR Review with Checklist

Review PRs against a project-specific checklist:

.claude/skills/pr-check/
├── SKILL.md
└── checklist.md

SKILL.md:

---
name: pr-check
description: Review PR against project checklist
disable-model-invocation: true
context: fork
---

## PR Context
- Diff: !`gh pr diff`
- Description: !`gh pr view`

Review against [checklist.md](checklist.md).

For each item, mark ✅ or ❌ with explanation.

checklist.md:

## PR Checklist

- [ ] Tests added for new functionality
- [ ] No console.log statements
- [ ] Error handling includes user-facing messages
- [ ] API changes are backwards compatible
- [ ] Database migrations are reversible

---

Release Notes Generator

Generate release notes from git history:

SKILL.md:

---
name: release-notes
description: Generate release notes from commits since last tag
disable-model-invocation: true
---

## Recent Changes
- Commits since last tag: !`git log $(git describe --tags --abbrev=0)..HEAD --oneline`
- Last tag: !`git describe --tags --abbrev=0`

Generate release notes:
1. Group commits by type (feat, fix, docs, etc.)
2. Write user-friendly descriptions
3. Highlight breaking changes
4. Format as markdown

---

Project Conventions (Claude-only)

Background knowledge Claude applies automatically:

SKILL.md:

---
name: project-conventions
description: Code style and patterns for this project. Apply when writing or reviewing code.
user-invocable: false
---

## Naming Conventions
- React components: PascalCase
- Utilities: camelCase
- Constants: UPPER_SNAKE_CASE
- Files: kebab-case

## Patterns
- Use `Result<T, E>` for fallible operations, not exceptions
- Prefer composition over inheritance
- All API responses use `{ data, error, meta }` shape

## Forbidden
- No `any` types
- No `console.log` in production code
- No synchronous file I/O

---

Environment Setup

Onboard new developers with setup script:

.claude/skills/setup-dev/
├── SKILL.md
└── scripts/
    └── check-prerequisites.sh

SKILL.md:

---
name: setup-dev
description: Set up development environment for new contributors
disable-model-invocation: true
---

Set up development environment:

1. Check prerequisites: `bash scripts/check-prerequisites.sh`
2. Install dependencies: `npm install`
3. Copy environment template: `cp .env.example .env`
4. Set up database: `npm run db:setup`
5. Verify setup: `npm test`

Report any issues encountered.

---

Argument Patterns

Arguments are appended as ARGUMENTS: <value> if $ARGUMENTS isn't in the skill.

Dynamic Context Injection

Use !command`` to inject live data before the skill runs:

## Current State
- Branch: !`git branch --show-current`
- Status: !`git status --short`

The command output replaces the placeholder before Claude sees the skill content.

Subagent Recommendations

Subagents are specialized Claude instances that run in parallel, each with their own context window and tool access. They're ideal for focused reviews, analysis, or generation tasks.

Note: These are common patterns. Design custom subagents based on the codebase's specific review and analysis needs.

Code Review Agents

code-reviewer

Best for: Automated code quality checks on large codebases

Value: Runs code review in parallel while you continue working Model: sonnet (balanced quality/speed) Tools: Read, Grep, Glob, Bash

---

security-reviewer

Best for: Security-focused code review

Value: Catches OWASP vulnerabilities, auth issues, data exposure Model: sonnet Tools: Read, Grep, Glob (read-only for safety)

---

test-writer

Best for: Generating comprehensive test coverage

Value: Generates tests matching project conventions Model: sonnet Tools: Read, Write, Grep, Glob

---

Specialized Agents

api-documenter

Best for: API documentation generation

Value: Generates OpenAPI specs, endpoint documentation Model: sonnet Tools: Read, Write, Grep, Glob

---

performance-analyzer

Best for: Finding performance bottlenecks

Value: Finds N+1 queries, O(n²) algorithms, memory leaks Model: sonnet Tools: Read, Grep, Glob, Bash

---

ui-reviewer

Best for: Frontend accessibility and UX review

Value: Catches accessibility issues, UX problems, responsive design gaps Model: sonnet Tools: Read, Grep, Glob

---

Utility Agents

dependency-updater

Best for: Safe dependency updates

Value: Updates dependencies incrementally with testing Model: sonnet Tools: Read, Write, Bash, Grep

---

migration-helper

Best for: Framework/version migrations

Value: Plans and executes migrations incrementally Model: opus (complex reasoning needed) Tools: Read, Write, Grep, Glob, Bash

---

Quick Reference: Detection → Recommendation

---

Subagent Placement

Subagents go in .claude/agents/:

.claude/
└── agents/
    ├── code-reviewer.md
    ├── security-reviewer.md
    └── test-writer.md

---

Model Selection Guide

---

Tool Access Guide