Awesome-omni-skill tech-detection

Detects project tech stack including languages, frameworks, package managers, and cloud platforms. Use when analyzing a project, detecting technologies, bootstrapping infrastructure, or setting up permissions. Generates project-context.json with detected stack.

install

source · Clone the upstream repo

git clone https://github.com/diegosouzapw/awesome-omni-skill

Claude Code · Install into ~/.claude/skills/

T=$(mktemp -d) && git clone --depth=1 https://github.com/diegosouzapw/awesome-omni-skill "$T" && mkdir -p ~/.claude/skills && cp -r "$T/skills/devops/tech-detection" ~/.claude/skills/diegosouzapw-awesome-omni-skill-tech-detection && rm -rf "$T"

manifest: skills/devops/tech-detection/SKILL.md

source content

Tech Detection Skill

You are a tech stack detection specialist. Your role is to analyze projects and determine their technology stack with high accuracy.

When to Activate

Project analysis requested
Stack detection needed
Permissions need updating based on tech
New project bootstrap (
```
/claudenv
```
)
Cloud platform configuration

Detection Process

Step 1: Run Detection Script

bash .claude/scripts/detect-stack.sh

Step 2: Analyze Results

Parse the JSON output and assess:

Languages: What programming languages are used?
Frameworks: What frameworks are detected?
Package Manager: npm, yarn, pnpm, pip, cargo, etc.?
Test Runner: jest, vitest, pytest, rspec, etc.?
Database/ORM: prisma, drizzle, mongoose, etc.?
Cloud Platforms: AWS, GCP, Azure, Heroku, Vercel, etc.?
Infrastructure: Docker, Kubernetes, CI/CD?

Step 3: Determine Confidence

HIGH: Clear package manager + framework + established patterns
MEDIUM: Some indicators but incomplete picture
LOW: Minimal or no indicators (new/empty project)

Step 4: Generate Permissions

Based on detected tech, look up commands in:

assets/command-mappings.json

Merge the appropriate command sets into the project's settings.json.

Step 5: Create project-context.json

Write the detection results to

.claude/project-context.json

for reference by other skills.

Cloud Platform Detection

The script detects these cloud platforms:

Platform	Detection Files
AWS	`samconfig.toml` , `template.yaml` , `cdk.json` , `amplify.yml` , `aws-exports.js` , `.aws/` , `buildspec.yml`
GCP	`app.yaml` , `cloudbuild.yaml` , `.gcloudignore` , `.gcloud/`
Azure	`azure-pipelines.yml` , `.azure/` , `azuredeploy.json`
Heroku	`Procfile` , `app.json` , `heroku.yml`
Vercel	`vercel.json`
Netlify	`netlify.toml`
Fly.io	`fly.toml`
Railway	`railway.json`
DigitalOcean	`.do/app.yaml` , `do.yaml`
Cloudflare	`wrangler.toml` , `wrangler.json`
Supabase	`supabase/` , `supabase/config.toml`
Firebase	`firebase.json` , `.firebaserc`

Command Mapping Reference

See

command-mappings.json

for the full mapping of technologies to allowed commands.

Example mappings:

```
npm
```
detected → add
```
npm *
```
,
```
npx *
```
,
```
node *
```
```
aws
```
detected → add
```
aws *
```
,
```
sam *
```
,
```
cdk *
```
,
```
amplify *
```
```
gcp
```
detected → add
```
gcloud *
```
,
```
gsutil *
```
,
```
bq *
```
```
heroku
```
detected → add
```
heroku *
```
```
prisma
```
detected → add
```
prisma *
```
```
docker
```
detected → add
```
docker *
```
,
```
docker-compose *
```

Low Confidence Handling

If confidence is LOW:

Inform the user of limited detection
Recommend running
```
/interview
```
to clarify tech stack
Ask if they want to proceed with interview or use defaults

Files Used

```
.claude/scripts/detect-stack.sh
```
- Detection script
```
assets/command-mappings.json
```
- Tech→commands map
```
.claude/project-context.json
```
- Output location
```
.claude/settings.json
```
- Permissions to update

Agent Creation

IMPORTANT: After tech detection completes, create specialist agents for detected technologies.

Step 6: Create Specialist Agents

For each detected technology that benefits from specialized expertise:

Check if agent already exists in
```
.claude/agents/
```
If not exists, invoke
```
agent-creator
```
to create it
Log created agents to
```
pending-agents.md
```
for tracking

Tech-to-Agent Mapping

Detected Tech	Agent to Create
React	`react-specialist`
Vue	`vue-specialist`
Angular	`angular-specialist`
Next.js	`nextjs-specialist`
Nuxt	`nuxt-specialist`
Django	`django-specialist`
FastAPI	`fastapi-specialist`
AWS	`aws-architect`
GCP	`gcp-architect`
Azure	`azure-architect`
Prisma	`prisma-specialist`
Drizzle	`drizzle-specialist`
Stripe	`stripe-specialist`
GraphQL	`graphql-architect`

Agent Creation Process

For each detected technology:
1. Look up in tech-agent-mappings
2. Check if .claude/agents/{name}.md exists
3. If not exists:
   - Invoke agent-creator skill
   - Pass technology name and detected context
   - agent-creator researches and generates agent file
4. Report created agents in bootstrap summary

See

.claude/skills/agent-creator/references/tech-agent-mappings.md

for full mapping.

LSP Auto-Setup

IMPORTANT: After tech detection completes, ALWAYS run LSP setup:

bash .claude/scripts/lsp-setup.sh

This automatically:

Detects all languages in the project
Installs required language servers
Configures LSP for code intelligence

LSP provides:

Go to definition
Find references
Hover documentation
Symbol navigation
Call hierarchy

Delegation

Hand off to other skills when:

Condition	Delegate To
Tech stack confidence is LOW	`interview-agent` - to clarify requirements
New/unfamiliar technology detected 2+ times	`meta-skill` - to create specialist skill
Detected tech needs specialist agent	`agent-creator` - to create specialist subagent
Frontend tech detected (React, Vue, Tailwind, etc.)	`frontend-design` - for UI/styling tasks
Architecture decisions needed	`interview-agent` - to gather requirements
Languages detected	`lsp-agent` - to install language servers

Auto-actions:

When detection completes with LOW confidence, automatically suggest invoking the interview-agent.
When detection completes, automatically run LSP setup for all detected languages.
When detection completes, invoke
```
agent-creator
```
for technologies needing specialist agents.