Claude Code Context Provider

Provides Claude Code with comprehensive project context from CLAUDE.md files, enabling informed development decisions, accurate code generation, and deep understanding of project architecture, conventions, and workflows.

What This Skill Does

Extracts and injects structured project context from CLAUDE.md documentation files into Claude Code's working memory. This ensures Claude understands your project's architecture, conventions, tech stack, deployment strategy, and development workflows before writing any code.

When to Use This Skill

Starting work on a new repository with a CLAUDE.md file

Onboarding Claude Code to an unfamiliar codebase

Before making architectural changes or refactoring

When Claude needs to understand project-specific conventions

Before generating code that must follow project patterns

When debugging issues requiring deep project knowledge

Step-by-Step Instructions

1. Locate the CLAUDE.md File

Search for CLAUDE.md in the repository root:

```bash

Check if CLAUDE.md exists

if [ -f "CLAUDE.md" ]; then

echo "CLAUDE.md found at project root"

else

echo "CLAUDE.md not found - searching subdirectories"

find . -name "CLAUDE.md" -type f

```

If no CLAUDE.md exists, inform the user that this skill requires a CLAUDE.md file and suggest creating one based on project documentation.

2. Read and Parse the Context File

Read the entire CLAUDE.md file to extract structured information:

**Project Overview**: Name, purpose, tech stack

**Architecture**: Directory structure, module organization, design patterns

**Key Conventions**: Naming conventions, code style, prefix/suffix patterns

**Configuration**: Environment variables, build configuration, deployment settings

**Development Workflows**: Testing commands, deployment process, branching strategy

**Dependencies**: External libraries, internal modules, API integrations

**Security Considerations**: CSP policies, authentication, rate limiting

**Common Commands**: Build, test, deploy, debug commands

3. Identify Critical Patterns

Extract and memorize project-specific patterns:

**Namespace conventions** (e.g., `BMS` global namespace, `bms-` CSS prefix)

**Module loading strategies** (e.g., dynamic component loading from GitHub)

**Error handling patterns** (e.g., graceful degradation, fallbacks)

**Testing approach** (e.g., local HTML test files, no build process)

**Deployment mechanism** (e.g., push to GitHub main, raw URLs in production)

4. Map Technology Stack

Identify all technologies and tools:

**Languages**: JavaScript versions, CSS preprocessors, etc.

**Frameworks**: React, Vue, vanilla JS, etc.

**Build tools**: Webpack, Vite, Turbopack, or none

**Testing**: Jest, Mocha, browser-based, etc.

**Deployment**: Railway, Vercel, GitHub Pages, raw GitHub URLs

**CI/CD**: GitHub Actions, Railway auto-deploy, etc.

5. Extract Architectural Constraints

Note any limitations or critical requirements:

**Security policies** (e.g., CSP restrictions, sites where code won't work)

**Browser compatibility** requirements

**Performance constraints** (e.g., file size limits for bookmarklets)

**Dependency restrictions** (e.g., zero external dependencies)

**API rate limits** or quotas

6. Load Related Documentation

If CLAUDE.md references other files, read them:

README.md for public-facing documentation

SECURITY.md for security policies

Architecture diagrams or API documentation

Example code or templates

7. Confirm Context Loaded

Summarize the loaded context for the user:

```

✓ Project: [Name]

✓ Tech Stack: [Primary technologies]

✓ Architecture: [Key patterns]

✓ Conventions: [Critical rules]

✓ Environment: [Dev/staging/prod setup]

✓ Constraints: [Important limitations]

Context loaded. Ready to work on this project.

```

8. Maintain Context Awareness

Throughout the session:

**Validate code against conventions** before writing

**Check architectural patterns** before suggesting changes

**Reference specific CLAUDE.md sections** when explaining decisions

**Flag potential violations** of documented constraints

**Suggest improvements** aligned with project philosophy

Examples

Example 1: Bookmarklet Project (from source content)

**User**: "Add a new bookmarklet that extracts page metadata"

**Claude Code**:

1. Reads CLAUDE.md to understand BMS namespace, component system, dark theme defaults

2. Notes CSS prefix convention (`bms-`)

3. Identifies loader pattern (GitHub raw URLs)

4. Creates `JavaScript/MetadataExtractor-refactored.js` with BMS.runMetadataExtractor function

5. Uses `await BMS.loadComponents(['core/panel/panel'])` for dynamic loading

6. Includes dark theme and animation support

7. Creates minified loader in `Bookmarklets/loaders/MetadataExtractor-loader.js`

8. Warns about CSP limitations on GitHub.com

Example 2: Next.js App with Railway Deployment

**User**: "Add a new API endpoint for user preferences"

**Claude Code**:

1. Reads CLAUDE.md to understand Railway multi-environment setup

2. Notes database schema location (`src/lib/db/schema.ts`)

3. Identifies auth pattern (NextAuth v5, session object structure)

4. Checks environment variables needed (`DATABASE_URL`, `AUTH_SECRET`)

5. Creates API route following existing patterns in `/api`

6. Adds rate limiting using `src/lib/ip-rate-limit.ts`

7. Updates schema if needed, reminds to run `drizzle-kit push` on all 3 DBs

8. Follows security practices from SECURITY.md (generic error messages, input validation)

Example 3: Component Library

**User**: "Create a new dropdown component"

**Claude Code**:

1. Reads CLAUDE.md to understand component architecture

2. Checks naming conventions for component files

3. Identifies existing styling patterns (CSS modules, Tailwind, etc.)

4. Notes accessibility requirements mentioned in docs

5. Creates component following established patterns

6. Adds dark theme support if project uses it

7. Includes animation hooks if project uses them

8. Updates component index/registry if needed

Important Notes

**Always read CLAUDE.md before writing code** - never assume project structure

**Respect documented constraints** - e.g., CSP limitations for bookmarklets

**Follow naming conventions strictly** - inconsistency breaks project patterns

**Check environment-specific requirements** - dev/staging/prod may differ

**Ask for clarification** if CLAUDE.md conflicts with user request

**Update mental model** as you discover new patterns in the codebase

**Reference specific line numbers** when explaining decisions based on CLAUDE.md

Constraints

CLAUDE.md must exist in the repository (root or subdirectory)

File must be readable and well-structured markdown

If CLAUDE.md is outdated, flag discrepancies with actual codebase

Do not blindly follow CLAUDE.md if it contradicts modern best practices - discuss with user

Some projects may have CLAUDE.md in multiple directories (monorepos) - load all relevant ones

Claude Code Context Provider

Claude Code Context Provider

What This Skill Does

When to Use This Skill

Step-by-Step Instructions

1. Locate the CLAUDE.md File

Check if CLAUDE.md exists

2. Read and Parse the Context File

3. Identify Critical Patterns

4. Map Technology Stack

5. Extract Architectural Constraints

6. Load Related Documentation

7. Confirm Context Loaded

8. Maintain Context Awareness

Examples

Example 1: Bookmarklet Project (from source content)

Example 2: Next.js App with Railway Deployment

Example 3: Component Library

Important Notes

Constraints

Reviews (0)