context-detection
Automatically detect project tech stack, frameworks, and development context
Best use case
context-detection is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Automatically detect project tech stack, frameworks, and development context
Teams using context-detection should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/context-detection/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How context-detection Compares
| Feature / Agent | context-detection | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Automatically detect project tech stack, frameworks, and development context
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Project Context Detection
Automatically analyzes the current project to detect technologies, frameworks, and development patterns.
## When to Use
This skill is invoked when:
- Running `/auto-skills` command
## Detection Methods
### 1. File System Analysis
Check for configuration files and lock files:
| Technology | Indicators |
|------------|------------|
| **Node.js** | `package.json`, `package-lock.json`, `yarn.lock`, `pnpm-lock.yaml` |
| **Go** | `go.mod`, `go.sum`, `*.go` files |
| **Python** | `requirements.txt`, `pyproject.toml`, `Pipfile`, `poetry.lock` |
| **Ruby** | `Gemfile`, `Gemfile.lock` |
| **Rust** | `Cargo.toml`, `Cargo.lock` |
| **Java** | `pom.xml`, `build.gradle` |
| **TypeScript** | `tsconfig.json` |
### 2. Framework Detection
| Framework | Indicators |
|-----------|------------|
| **Next.js** | `next.config.js`, `app/` directory with `page.tsx` |
| **React** | `package.json` contains `react`, JSX files |
| **Vue** | `package.json` contains `vue`, `.vue` files |
| **GraphQL** | `.graphql` files, `schema.graphql`, Apollo/GraphQL in deps |
| **Express** | `express` in dependencies |
| **FastAPI** | `fastapi` in dependencies |
| **Django** | `django` in dependencies, `manage.py` |
| **Rails** | `rails` in dependencies, `config/routes.rb` |
### 3. Testing Frameworks
| Framework | Indicators |
|-----------|------------|
| **Jest** | `jest.config.js`, `*.test.js`, `*.spec.js` |
| **Playwright** | `playwright.config.js`, `*.spec.ts` |
| **Pytest** | `pytest.ini`, `conftest.py`, `test_*.py` |
| **Go testing** | `*_test.go` files |
### 4. Code Analysis
Analyze file extensions and imports:
- Count file types (`.go`, `.tsx`, `.py`, etc.)
- Analyze import statements for frameworks
- Check for API routes, database schemas
## Output Format
Return a structured context object:
```json
{
"languages": ["go", "javascript"],
"frameworks": ["nextjs", "graphql"],
"testing": ["playwright", "go-testing"],
"packageManager": "pnpm",
"hasApi": true,
"hasDatabase": true,
"projectType": "fullstack"
}
```
## Example Workflow
When detecting context for a project:
1. Scan root directory for config files
2. Analyze `package.json`, `go.mod`, or equivalent
3. Count file types in `src/` or main directories
4. Check for test files and frameworks
5. Return structured context for auto-installation decisions
## Integration
This skill feeds into:
- **scan**: Determines which SkillsMP skills to fetchRelated Skills
contextui
Build, run, and publish visual workflows on ContextUI — a local-first desktop platform for AI agents. Create React TSX workflows (dashboards, tools, apps, visualizations), manage local Python backend servers, test workflows via scoped UI automation within the ContextUI app window, and optionally publish to the ContextUI Exchange. All tools operate locally on the user's machine under standard OS permissions — no remote execution or privilege escalation. Python backends bind to localhost. See SECURITY.md for the full capability scope and trust model. Requires ContextUI installed locally and MCP server configured.
contextual-pattern-learning
Advanced contextual pattern recognition with project fingerprinting, semantic similarity analysis, and cross-domain pattern matching for enhanced learning capabilities
context7
Fetch up-to-date library documentation via Context7 REST API. Use when needing current API docs, framework patterns, or code examples for any library. Use when user asks about React, Next.js, Prisma, Express, Vue, Angular, Svelte, or any npm/PyPI package. Use when user says 'how do I use X library', 'what's the API for Y', or needs official documentation. Lightweight alternative to Context7 MCP with no persistent context overhead.
context7-usage
Patterns for using Context7 MCP for library documentation (v2.25)
context7-efficient
Token-efficient library documentation fetcher using Context7 MCP with 86.8% token savings through intelligent shell pipeline filtering. Fetches code examples, API references, and best practices for JavaScript, Python, Go, Rust, and other libraries. Use when users ask about library documentation, need code examples, want API usage patterns, are learning a new framework, need syntax reference, or troubleshooting with library-specific information. Triggers include questions like "Show me React hooks", "How do I use Prisma", "What's the Next.js routing syntax", or any request for library/framework documentation.
context7-docs
Fetch official library docs via Context7 MCP. Use for Tailwind CSS docs (grid, responsive variants), React, Next.js, Vue, MCP, OpenCode, or any npm library. Always use before external web search.
context7-auto-research
Automatically fetch latest library/framework documentation for Claude Code via Context7 API
context-optimization
Apply compaction, masking, and caching strategies
context-memory
Advanced context and memory management system for AI agents. Provides persistent memory across sessions through daily logs (memory/YYYY-MM-DD.md), long-term curated memory (MEMORY.md), conversation archives with semantic search, and automatic behavioral learning from user satisfaction tracking. Use when you need to: (1) Remember information across sessions, (2) Archive conversations before context loss, (3) Search past discussions, (4) Track and learn from user satisfaction patterns, (5) Maintain session continuity, (6) Implement proactive memory maintenance. Includes conversation-archiver.py and satisfaction-tracker.py scripts, session startup routines, and periodic reflection workflows.
context-engineering
Use when starting a new session, when agent output quality degrades, when switching between tasks, or when you need to configure rules files and context for a project.
context-driven-development
Use this skill when working with Conductor's context-driven development methodology, managing project context artifacts, or understanding the relationship between product.md, tech-stack.md, and...
context-detector
Detect project language, framework, and existing conventions. Use when creating workflows to adapt generated artifacts to match project patterns.