Suggesting Tooling

Analyzes codebases to suggest custom skills and agents for workflow automation.

Quick Start

1. Scan codebase for patterns (languages, frameworks, workflows)
2. Match patterns to skill/agent templates
3. Present suggestions with rationale
4. Generate approved tooling using creating-skills/creating-agents

Workflow

Progress:
- [ ] Analyze codebase patterns
- [ ] Match to tooling templates
- [ ] Present suggestions
- [ ] Generate approved items

Step 1: Analyze Codebase

Run lightweight analysis:

# Language detection
find . -type f -name "*.ts" -o -name "*.js" -o -name "*.py" | head -100

# Framework detection
ls package.json pyproject.toml Cargo.toml go.mod 2>/dev/null

# Workflow detection
ls .github/workflows/ .gitlab-ci.yml Dockerfile 2>/dev/null

# Existing tooling
ls .claude/skills/ .claude/agents/ 2>/dev/null

Collect:

• Primary language(s)
• Framework(s) in use
• Build/test tooling
• CI/CD setup
• Existing .claude/ configuration

Step 2: Pattern Matching

Match detected patterns to suggestions:

See patterns/skills.md and patterns/agents.md for complete mappings.

Step 3: Present Suggestions

Format suggestions for user review:

## Tooling Suggestions for {project}

Based on analysis of your codebase:
- Language: {detected}
- Framework: {detected}
- Existing tooling: {count} skills, {count} agents

### Recommended Skills

| # | Skill | Why | Priority |
|---|-------|-----|----------|
| 1 | {name} | {rationale} | P1 |
| 2 | {name} | {rationale} | P2 |

### Recommended Agents

| # | Agent | Why | Priority |
|---|-------|-----|----------|
| 1 | {name} | {rationale} | P1 |

Then ask user which to generate.

Step 4: Generate Tooling

For each approved item:

Skills - Invoke creating-skills:

Use the creating-skills skill to create a {name} skill.

Purpose: {rationale}
Detected context:
- Framework: {framework}
- Test runner: {runner}
- Patterns: {patterns}

Generate a focused skill for this project.

Agents - Invoke creating-agents:

Use the creating-agents skill to create a {name} agent.

Purpose: {rationale}
Suggested tools: {tools}
Detected context:
- Project type: {type}
- Workflows: {workflows}

Generate a focused agent for this project.

Pattern Categories

Testing

• Signals: jest.config, pytest.ini, mocha, test/ directory
• Suggest: testing-code skill
• Priority: P1 if tests exist but no skill

API Development

• Signals: Express routes, FastAPI, REST patterns
• Suggest: api-testing agent
• Priority: P1 if API-heavy project

Database

• Signals: Prisma, TypeORM, migrations/
• Suggest: db-migrations skill
• Priority: P2

DevOps

• Signals: Dockerfile, docker-compose, CI configs
• Suggest: deploying-code skill
• Priority: P2 if no deployment automation

Code Quality

• Signals: ESLint, Prettier, pre-commit
• Suggest: linting-code skill
• Priority: P3

Security

• Signals: Auth middleware, JWT, OAuth
• Suggest: security-review agent
• Priority: P1 for auth-heavy projects

See reference.md for detailed pattern definitions.

Gap Analysis

Compare detected needs against existing .claude/ configuration:

Detected workflows:     Existing tooling:
- Testing (Jest)        - (none)
- API (Express)         - (none)
- CI (GitHub Actions)   - (none)

Gaps: testing, api-testing, deployment

Only suggest tooling that fills gaps.

Output Format

After generation, report:

## Tooling Created

| Type | Name | Location |
|------|------|----------|
| Skill | testing-code | .claude/skills/testing-code/ |
| Agent | code-reviewer | .claude/agents/code-reviewer.md |

### Restart Required

New skills and agents require a Claude restart to be available.

To continue where you left off:
\`\`\`bash
claude --continue
\`\`\`

### Next Steps

1. Restart Claude to load new tooling
2. Run `claude --continue` to resume
3. Review generated tooling in .claude/
4. Test skills with sample workflows

Limits

• Maximum 5 suggestions per category
• Require explicit approval before generating
• Skip suggestions for existing tooling
• Prioritize by impact (P1 first)