Context Detector

When to Use This Skill

• •Creating new workflows that should match project conventions
• •Detecting project language and framework
• •Analyzing existing artifacts for naming patterns
• •Adapting tool suggestions to project stack

Language Detection

Check these files to detect project language:

Framework Detection

JavaScript/TypeScript Frameworks

Check package.json dependencies:

Python Frameworks

Check pyproject.toml or requirements.txt:

Tool Suggestions by Stack

Node.js/TypeScript

{
  "formatter": "prettier",
  "linter": "eslint",
  "test": "jest or vitest",
  "typecheck": "tsc --noEmit"
}

Python

{
  "formatter": "black",
  "linter": "ruff or flake8",
  "imports": "isort",
  "test": "pytest",
  "typecheck": "mypy"
}

Rust

{
  "formatter": "rustfmt",
  "linter": "clippy",
  "test": "cargo test"
}

Go

{
  "formatter": "gofmt",
  "linter": "golangci-lint",
  "test": "go test"
}

Existing Artifact Analysis

Scan for Existing Patterns

1. •

   Commands: Read files in .claude/commands/

   • •Extract naming conventions (kebab-case, namespaces)
   • •Note frontmatter patterns used
   • •Identify tool access patterns
2. •

   Skills: Read .claude/skills/*/SKILL.md

   • •Extract description style
   • •Note trigger patterns
   • •Identify structure conventions
3. •

   Agents: Read .claude/agents/*.md

   • •Extract naming patterns
   • •Note tool scoping patterns
   • •Identify output format conventions
4. •

   Hooks: Read .claude/settings.json

   • •Identify existing hook patterns
   • •Note script locations
   • •Check for conflicts

Convention Extraction Checklist

• • Naming: kebab-case, snake_case, or camelCase?
• • Description length: short (<100 chars) or detailed?
• • Tool scoping: minimal or generous?
• • Output format: markdown, JSON, or plain text?
• • Error handling: fail fast or graceful degradation?

Adapting to Conventions

Match Existing Command Style

If existing commands use:

---
allowed-tools: Read, Write
description: Short description
---

New commands should match that structure.

Match Hook Patterns

If project uses hook scripts in .claude/hooks/:

• •Create new scripts there, not inline
• •Match the shebang style (#!/bin/bash vs #!/usr/bin/env bash)
• •Match error handling patterns

Match Skill Structure

If existing skills have:

## When to Use
## Process
## Output Format

New skills should use the same sections.

Detection Process

Step 1: Identify Language

# Check for config files
ls -la package.json Cargo.toml go.mod pyproject.toml 2>/dev/null

Step 2: Identify Framework

# For Node.js
cat package.json | jq '.dependencies | keys'

Step 3: Scan Existing Artifacts

# Count existing artifacts
ls -la .claude/commands/**/*.md 2>/dev/null | wc -l
ls -la .claude/skills/*/SKILL.md 2>/dev/null | wc -l
ls -la .claude/agents/*.md 2>/dev/null | wc -l

Step 4: Extract Conventions

Read 2-3 examples of each type and note patterns.

Output Format

When reporting detected context:

## Project Context

### Language/Framework
- Primary: TypeScript
- Framework: Next.js
- Test Framework: Jest

### Detected Tools
- Formatter: prettier (in package.json)
- Linter: eslint (in package.json)
- Build: next build

### Existing Artifacts
- Commands: 3 (kebab-case naming)
- Skills: 2 (detailed descriptions)
- Agents: 1 (minimal tool scope)
- Hooks: 2 (script-based in .claude/hooks/)

### Conventions
- Descriptions: Under 100 chars
- Tools: Minimal scoping
- Output: Markdown format

Anti-Patterns

❌ Assuming stack without checking

Always verify by reading config files.

❌ Ignoring existing patterns

Match existing conventions even if not optimal.

❌ Over-detecting

Focus on what matters for artifact generation.

❌ Hard-coding tool choices

Adapt to what the project actually uses.