template-blueprints

Original source / Raw SKILL.md

---
name: template-blueprints
description: Access pattern library extracted from existing templates for reuse when creating new templates. Use when creating .md files for commands, agents, skills or when generating CLAUDE.md, README.md, or settings.json. Provides templatable patterns and quick-start presets.
allowed-tools: Read, Write, Grep
---

You are a template pattern library expert. You provide reusable patterns, templates, and blueprints extracted from the existing 7 high-quality templates in this repository.

## Your Purpose

When creating new templates, you help ensure:
1. **Consistency** - New templates follow established patterns
2. **Quality** - Leverage proven structures from existing templates
3. **Speed** - Reuse instead of creating from scratch
4. **Completeness** - Don't forget essential components

## What You Provide

### 1. Pattern Libraries

**Common Command Patterns** (`common-commands.json`):
- Templatable command structures for typical operations
- Standard frontmatter patterns
- Argument handling patterns
- Tool restriction patterns

**Common Agent Patterns** (`common-agents.json`):
- Reusable agent role templates (security, testing, performance, expert)
- Standard activation triggers
- Methodology structures
- Best practices sections

**Documentation Templates** (`documentation-templates/`):
- README.md structure template
- CLAUDE.md structure template
- setup_instructions.md template
- Section templates with placeholder text

### 2. Quick-Start Presets

Pre-configured minimal templates for instant start (`presets/`):
- `minimal-backend-api.json` - REST API starter
- `minimal-frontend-spa.json` - Frontend SPA starter
- `minimal-desktop-gui.json` - Desktop app starter
- `standard-web-fullstack.json` - Full-stack template
- `data-pipeline.json` - Data/scraping template

### 3. Pattern Reference Guide

Comprehensive analysis of existing templates (`reference.md`):
- Quantitative patterns (10-12 commands, 5-6 agents, 3-4 skills)
- Command category patterns
- Agent role patterns
- Skill type patterns
- Documentation structure patterns

## How to Use This Skill

### When Creating Commands

**Instead of writing from scratch**:
```yaml
---
description: ???
---

What should this do?
```

**Use command patterns from `common-commands.json`**:
```yaml
---
description: Run development server with hot-reload
argument-hint: [--port PORT]
allowed-tools: Bash(*)
---

Start the {FRAMEWORK} development server with hot-reload enabled.

Arguments:
- $1: Port number (optional, defaults to {DEFAULT_PORT})

Usage:
- `/{COMMAND}` - Start on default port
- `/{COMMAND} 8080` - Start on custom port

This will:
1. Check if port is available
2. Start development server
3. Display access URL
```

### When Creating Agents

**Instead of starting blank**:
```yaml
---
name: ???
description: ???
---

What should this agent do?
```

**Use agent patterns from `common-agents.json`**:
```yaml
---
name: {framework}-security
description: PROACTIVELY review {FRAMEWORK} code for security vulnerabilities, OWASP risks, and framework-specific security issues. MUST BE USED when reviewing authentication, permissions, user input handling, or when explicitly requested for security review.
tools: Read, Grep, Bash
model: sonnet
---

You are a {FRAMEWORK} security expert specializing in identifying and preventing security vulnerabilities.

## Your Responsibilities

1. **OWASP Top 10 Prevention**
   - SQL Injection / NoSQL Injection
   - XSS (Cross-Site Scripting)
   - CSRF (Cross-Site Request Forgery)
   - Authentication/Authorization flaws
   ...
```

### When Creating Documentation

**Use templates from `documentation-templates/`**:

Read `documentation-templates/README_template.md` and fill in framework-specific content:
- Replace `{FRAMEWORK_NAME}` with actual framework
- Replace `{VERSION}` with version info
- Fill in `{FEATURES_LIST}` with actual features
- Customize `{PROJECT_STRUCTURE}` with real directory tree
- Add actual commands to `{COMMANDS_TABLE}`

### When Choosing Template Scope

**Reference `reference.md` for guidance**:

For a **minimal starter**:
- 5-6 essential commands (dev, test, lint, format, create-*)
- 3 core agents (security, framework-expert, test-generator)
- 1-2 skills (basic patterns, simple generator)

For a **standard template**:
- 10-12 commands (add DB commands, deployment, etc.)
- 5-6 agents (add performance, domain-specific agents)
- 3-4 skills (advanced patterns, validators)

For a **comprehensive template**:
- 12-15 commands (add CI/CD, monitoring, advanced ops)
- 6-8 agents (add architecture, optimization, specialized)
- 4-5 skills (complete pattern library)

### When Using Presets

**Load a preset from `presets/` directory**:

```json
// presets/minimal-backend-api.json
{
  "template_type": "backend-api",
  "depth": "minimal",
  "commands": ["dev", "test", "lint", "format", "create-route"],
  "agents": ["security", "api-expert", "test-generator"],
  "skills": ["api-patterns"],
  "features": {
    "database": true,
    "auth": false,
    "real_time": false,
    "file_uploads": false
  }
}
```

Use this as a starting point and customize based on specific framework and user requirements.

## Pattern Categories

### 1. Universal Commands (Every Template Needs)

**Development Server**:
- Purpose: Run local development environment
- Names: `dev`, `run`, `runserver`, `serve`
- Arguments: Usually `[--port PORT]` or `[--host HOST]`
- Tools: Bash(*)

**Testing**:
- Purpose: Execute test suite
- Names: `test`, `test-watch`, `coverage`
- Arguments: `[test_path]` or `[--watch]`
- Tools: Bash(*)

**Code Quality**:
- Purpose: Lint and format code
- Names: `lint`, `format`, `type-check`
- Arguments: `[--fix]` for auto-fix
- Tools: Bash(*)

**Build**:
- Purpose: Create production build
- Names: `build`, `compile`, `bundle`
- Arguments: `[--mode MODE]` for environment
- Tools: Bash(*)

### 2. Framework-Specific Commands

**Backend Frameworks** (Django, Flask, FastAPI):
- Database migrations: `migrate`, `db-upgrade`, `db-migrate`
- Database status: `db-status`, `showmigrations`
- Shell access: `shell`, `repl`
- Create model: `create-model`

**Frontend Frameworks** (React, Vue, Svelte):
- Create component: `create-component`
- Preview build: `preview`
- Dependency management: `install`, `add`, `remove`
- Bundle analysis: `analyze`

**Data Frameworks** (Streamlit, Jupyter):
- Run application: `run`
- Create page/view: `create-page`
- Data operations: `db-migrate`, `db-upgrade`

### 3. Universal Agent Roles (Every Template Needs)

**Security Agent**:
- Role: Identify vulnerabilities, review auth/permissions
- Activation: PROACTIVELY on security-sensitive code
- Tools: Read, Grep, Bash
- Naming: `{framework}-security`

**Framework Expert**:
- Role: Best practices, patterns, framework-specific guidance
- Activation: When working with framework-specific code
- Tools: Read, Write, Grep
- Naming: `{framework}-expert`

**Test Generator**:
- Role: Create comprehensive tests with edge cases
- Activation: PROACTIVELY when creating new features
- Tools: Read, Write, Bash
- Naming: `test-writer`, `test-generator`, `test-helper`

**Performance Optimizer**:
- Role: Identify bottlenecks, optimize queries/rendering
- Activation: When reviewing performance-critical code
- Tools: Read, Grep, Bash
- Naming: `performance-optimizer`, `api-optimizer`

### 4. Domain-Specific Agent Roles

**Backend-Specific**:
- `orm-optimizer` - Database query optimization
- `migration-helper` - Database schema changes
- `api-designer` - REST/GraphQL API design
- `schema-expert` - Data model design

**Frontend-Specific**:
- `component-architect` - Component structure and reuse
- `state-manager` - State management patterns
- `accessibility-reviewer` - A11y compliance
- `bundle-optimizer` - Bundle size and performance

### 5. Universal Skills (Every Template Needs)

**Framework Patterns**:
- Purpose: Implement common design patterns
- Name: `{framework}-patterns`
- Content: Pattern implementations with examples
- When: Refactoring or implementing standard patterns

**Code Generator**:
- Purpose: Generate boilerplate code
- Name: `{type}-generator` (component, API, model)
- Content: Templates for common structures
- When: Creating new features or files

**Validator**:
- Purpose: Check code quality and best practices
- Name: `{domain}-validator` (model, form, API)
- Content: Validation rules and checks
- When: Reviewing code or before commits

## Working with Patterns

### Step 1: Identify Similar Templates

Before creating a new template, find existing templates that are similar:

**New Python backend** → Study Django, Flask, FastAPI templates
**New JavaScript frontend** → Study React template
**New data application** → Study Streamlit template
**New scraping tool** → Study Scrapy template
**New desktop app** → Study Tkinter template

### Step 2: Extract Relevant Patterns

Look at the similar template's:
- `.claude/commands/` - What commands do they have?
- `.claude/agents/` - What agent roles are defined?
- `.claude/skills/` - What skills are provided?
- `CLAUDE.md` - What sections and content structure?
- `README.md` - How is it organized?

### Step 3: Adapt to New Framework

Take patterns and customize:
- Replace framework names
- Adjust tool/package names
- Modify code examples
- Update best practices
- Adapt conventions

### Step 4: Validate Completeness

Check against reference patterns:
- ✅ Have 10-12 commands covering all categories?
- ✅ Have 5-6 agents covering all roles?
- ✅ Have 3-4 skills covering key needs?
- ✅ Documentation is comprehensive?
- ✅ Framework files are included?

## Best Practices

### 1. Don't Reinvent the Wheel

If a pattern exists in another template and can be adapted, **use it**. This ensures consistency and quality.

**Example**: The security agent pattern works for all frameworks - just change framework-specific vulnerabilities.

### 2. Maintain Pattern Consistency

When creating similar components across templates:
- Use the same naming conventions
- Use the same frontmatter fields
- Use the same section structures
- Use similar examples and explanations

### 3. Learn from Complete Templates

The 6 complete templates (Django, React, Flask, Tkinter, Streamlit, Scrapy) are excellent:
- Study their structures before creating new templates
- Copy their documentation styles
- Reuse their agent methodologies
- Adapt their skill patterns

### 4. Use Presets as Starting Points

For quick template creation:
1. Select appropriate preset (backend, frontend, desktop, data)
2. Load preset configuration
3. Customize for specific framework
4. Expand based on user requirements
5. Validate completeness

### 5. Reference Documentation

Point users to:
- `reference.md` for quantitative patterns
- `common-commands.json` for command structures
- `common-agents.json` for agent templates
- `documentation-templates/` for doc structures

## Integration with Template Creation

### Used By Template-Creator

The template-creator agent should:
1. Read `reference.md` to understand patterns
2. Use `common-commands.json` for command files
3. Use `common-agents.json` for agent files
4. Use `documentation-templates/` for docs
5. Reference presets for scope guidance

### Used By Template-Wizard

The template-wizard agent should:
1. Reference presets for depth recommendations
2. Use `reference.md` for explaining what will be created
3. Show examples from existing templates

### Used By Developers

Manual template creators should:
1. Study `reference.md` for patterns
2. Copy structures from similar templates
3. Use JSON files as checklists
4. Follow documentation templates

## When to Use This Skill

Use this skill when:
- Creating a new project template
- Adding commands/agents/skills to a template
- Need examples of how to structure components
- Want to ensure consistency with existing templates
- Need to explain patterns to users
- Deciding what should be included in a template

## Available Files Reference

All files in this skill directory:

1. **SKILL.md** (this file) - Skill description and usage
2. **reference.md** - Comprehensive pattern analysis from existing templates
3. **common-commands.json** - Templatable command patterns
4. **common-agents.json** - Templatable agent patterns
5. **documentation-templates/** - README, CLAUDE.md, and setup templates
6. **presets/** - Quick-start template configurations

Read these files as needed when creating new templates.

## Success Metrics

This skill is successful when:
- ✅ New templates follow the same patterns as existing ones
- ✅ Template creation is faster (reuse vs create from scratch)
- ✅ Template quality is consistent across frameworks
- ✅ Common components (security agent, etc.) are standardized
- ✅ Documentation follows consistent structure
- ✅ Developers can easily understand what to include

Remember: The goal is **consistency, quality, and speed**. Every template should feel like it belongs to the same family while being appropriately customized for its specific framework.


---

## Referenced Files

> The following files are referenced in this skill and included for context.

### presets/minimal-backend-api.json

```json
{
  "preset_name": "minimal-backend-api",
  "description": "Minimal REST API backend starter template",
  "template_type": "backend-api",
  "depth": "minimal",
  "recommended_frameworks": [
    "FastAPI",
    "Flask",
    "Express"
  ],
  "commands": [
    {
      "name": "dev",
      "description": "Run development server with hot-reload",
      "priority": "essential"
    },
    {
      "name": "test",
      "description": "Run test suite",
      "priority": "essential"
    },
    {
      "name": "lint",
      "description": "Check code quality",
      "priority": "essential"
    },
    {
      "name": "format",
      "description": "Auto-format code",
      "priority": "essential"
    },
    {
      "name": "create-route",
      "description": "Generate new API route/endpoint",
      "priority": "essential"
    }
  ],
  "agents": [
    {
      "name": "security",
      "role": "Review code for security vulnerabilities",
      "priority": "required"
    },
    {
      "name": "api-expert",
      "role": "Framework-specific API best practices",
      "priority": "required"
    },
    {
      "name": "test-generator",
      "role": "Generate comprehensive tests",
      "priority": "required"
    }
  ],
  "skills": [
    {
      "name": "api-patterns",
      "description": "Common REST API design patterns"
    }
  ],
  "features": {
    "database": true,
    "auth": false,
    "real_time": false,
    "file_uploads": false,
    "background_jobs": false,
    "caching": false
  },
  "suggested_dependencies": {
    "python": [
      "Framework (fastapi/flask)",
      "Web server (uvicorn/gunicorn)",
      "ORM (sqlalchemy)",
      "Database driver (psycopg2/pymongo)",
      "Testing (pytest)",
      "Linting (ruff)",
      "Type checking (mypy)"
    ],
    "javascript": [
      "Framework (express)",
      "Database client (pg/mongodb)",
      "Testing (jest)",
      "Linting (eslint)",
      "Type checking (typescript)"
    ]
  },
  "estimated_files": {
    "commands": 5,
    "agents": 3,
    "skills": 1,
    "total_config_files": "~15"
  },
  "complexity": "low",
  "setup_time": "15-30 minutes",
  "ideal_for": [
    "Learning API development",
    "Microservices",
    "Simple backends",
    "Prototypes"
  ]
}

```

### documentation-templates/README_template.md

```markdown
# {FRAMEWORK_NAME} Project Template

{BRIEF_DESCRIPTION - 1-2 sentences about what this template provides}

## What's Included

- ✅ {FEATURE_1}
- ✅ {FEATURE_2}
- ✅ {FEATURE_3}
- ✅ {FEATURE_4}
- ✅ {FEATURE_5}
- ✅ {FEATURE_6}
- ✅ {FEATURE_7}
- ✅ {FEATURE_8}
- ✅ {FEATURE_9}
- ✅ {FEATURE_10}
- ✅ {FEATURE_11}
- ✅ {FEATURE_12}

{Add 8-12 key features}

## Quick Start

### Prerequisites

- **{REQUIREMENT_1}**: {VERSION} or higher - [{DOWNLOAD_LINK}]({URL})
- **{REQUIREMENT_2}**: {VERSION} or higher - [{DOWNLOAD_LINK}]({URL})
- **{REQUIREMENT_3}**: {VERSION_INFO} - [{DOWNLOAD_LINK}]({URL})

{List 3-5 prerequisites}

### Installation

1. **Clone or copy this template**:
   ```bash
   # {CLONE_INSTRUCTION}
   ```

2. **{STEP_2_TITLE}**:
   ```bash
   {STEP_2_COMMAND}
   ```
   {STEP_2_EXPLANATION}

3. **{STEP_3_TITLE}**:
   ```bash
   {STEP_3_COMMAND}
   ```
   {STEP_3_EXPLANATION}

4. **{STEP_4_TITLE}**:
   ```bash
   {STEP_4_COMMAND}
   ```
   {STEP_4_EXPLANATION}

5. **{STEP_5_TITLE}**:
   ```bash
   {STEP_5_COMMAND}
   ```
   {STEP_5_EXPLANATION}

{Add 5-8 installation steps}

### First Run

```bash
{RUN_COMMAND}
```

{WHAT_HAPPENS_DESCRIPTION}

Open your browser to `http://localhost:{PORT}` to see the application.

## Project Structure

```
{TEMPLATE_NAME}/
├── {DIR_1}/              # {DIR_1_DESCRIPTION}
│   ├── {SUBDIR_1_1}/     # {SUBDIR_1_1_DESCRIPTION}
│   └── {FILE_1_1}        # {FILE_1_1_DESCRIPTION}
├── {DIR_2}/              # {DIR_2_DESCRIPTION}
│   ├── {FILE_2_1}        # {FILE_2_1_DESCRIPTION}
│   └── {FILE_2_2}        # {FILE_2_2_DESCRIPTION}
├── {DIR_3}/              # {DIR_3_DESCRIPTION}
├── .claude/              # Claude Code configuration
│   ├── commands/         # {COMMAND_COUNT} slash commands
│   ├── agents/           # {AGENT_COUNT} specialized subagents
│   └── skills/           # {SKILL_COUNT} agent skills
├── .env.example          # Environment variable template
├── .gitignore            # Git ignore rules
├── CLAUDE.md             # Development context for Claude Code
├── README.md             # This file
└── {MAIN_FILE}           # {MAIN_FILE_DESCRIPTION}
```

{Customize directory tree to match your framework}

## Available Scripts / Commands

| Command | Description | Arguments |
|---------|-------------|-----------|
| `/{COMMAND_1}` | {DESCRIPTION_1} | {ARGS_1} |
| `/{COMMAND_2}` | {DESCRIPTION_2} | {ARGS_2} |
| `/{COMMAND_3}` | {DESCRIPTION_3} | {ARGS_3} |
| `/{COMMAND_4}` | {DESCRIPTION_4} | {ARGS_4} |
| `/{COMMAND_5}` | {DESCRIPTION_5} | {ARGS_5} |
| `/{COMMAND_6}` | {DESCRIPTION_6} | {ARGS_6} |
| `/{COMMAND_7}` | {DESCRIPTION_7} | {ARGS_7} |
| `/{COMMAND_8}` | {DESCRIPTION_8} | {ARGS_8} |
| `/{COMMAND_9}` | {DESCRIPTION_9} | {ARGS_9} |
| `/{COMMAND_10}` | {DESCRIPTION_10} | {ARGS_10} |

{Add all commands - typically 10-12}

### Example Usage

```bash
# {EXAMPLE_1_DESCRIPTION}
/{EXAMPLE_COMMAND_1}

# {EXAMPLE_2_DESCRIPTION}
/{EXAMPLE_COMMAND_2} {EXAMPLE_ARGS}

# {EXAMPLE_3_DESCRIPTION}
/{EXAMPLE_COMMAND_3}
```

## Subagents

This template includes {AGENT_COUNT} specialized subagents that automatically assist with different tasks:

### {AGENT_1_NAME}
**Triggers**: {WHEN_AGENT_1_ACTIVATES}

{AGENT_1_DESCRIPTION}

### {AGENT_2_NAME}
**Triggers**: {WHEN_AGENT_2_ACTIVATES}

{AGENT_2_DESCRIPTION}

### {AGENT_3_NAME}
**Triggers**: {WHEN_AGENT_3_ACTIVATES}

{AGENT_3_DESCRIPTION}

### {AGENT_4_NAME}
**Triggers**: {WHEN_AGENT_4_ACTIVATES}

{AGENT_4_DESCRIPTION}

### {AGENT_5_NAME}
**Triggers**: {WHEN_AGENT_5_ACTIVATES}

{AGENT_5_DESCRIPTION}

{Add all agents - typically 5-6}

## Skills

This template provides {SKILL_COUNT} specialized skills for code generation and pattern implementation:

### {SKILL_1_NAME}
**Purpose**: {SKILL_1_PURPOSE}

**When to use**: {SKILL_1_WHEN}

**What it provides**: {SKILL_1_PROVIDES}

### {SKILL_2_NAME}
**Purpose**: {SKILL_2_PURPOSE}

**When to use**: {SKILL_2_WHEN}

**What it provides**: {SKILL_2_PROVIDES}

### {SKILL_3_NAME}
**Purpose**: {SKILL_3_PURPOSE}

**When to use**: {SKILL_3_WHEN}

**What it provides**: {SKILL_3_PROVIDES}

{Add all skills - typically 3-4}

## Development Workflow

### Typical Development Cycle

1. **{WORKFLOW_STEP_1}**
   ```bash
   {WORKFLOW_COMMAND_1}
   ```
   {WORKFLOW_DESCRIPTION_1}

2. **{WORKFLOW_STEP_2}**
   ```bash
   {WORKFLOW_COMMAND_2}
   ```
   {WORKFLOW_DESCRIPTION_2}

3. **{WORKFLOW_STEP_3}**
   ```bash
   {WORKFLOW_COMMAND_3}
   ```
   {WORKFLOW_DESCRIPTION_3}

4. **{WORKFLOW_STEP_4}**
   ```bash
   {WORKFLOW_COMMAND_4}
   ```
   {WORKFLOW_DESCRIPTION_4}

{Describe typical workflow with 4-6 steps}

### Creating Your First {COMPONENT_TYPE}

```bash
/{CREATE_COMMAND} {EXAMPLE_NAME}
```

This generates:
- `{GENERATED_FILE_1}` - {FILE_1_PURPOSE}
- `{GENERATED_FILE_2}` - {FILE_2_PURPOSE}
{- `{GENERATED_FILE_3}` - {FILE_3_PURPOSE}}

{NEXT_STEPS_DESCRIPTION}

## Testing

### Running Tests

```bash
# Run all tests
/{TEST_COMMAND}

# Run specific test
/{TEST_COMMAND} {TEST_PATH_EXAMPLE}

# Run with coverage
/{TEST_COMMAND} --coverage
```

### Writing Tests

{TEST_WRITING_GUIDANCE - 2-3 paragraphs}

Example test structure:
```{language}
{TEST_EXAMPLE_CODE}
```

### Test Organization

```
{TEST_DIRECTORY_STRUCTURE}
```

{TEST_CONVENTIONS}

## Deployment

### {DEPLOYMENT_METHOD_1}

1. **{DEPLOY_STEP_1}**:
   ```bash
   {DEPLOY_COMMAND_1}
   ```

2. **{DEPLOY_STEP_2}**:
   ```bash
   {DEPLOY_COMMAND_2}
   ```

3. **{DEPLOY_STEP_3}**:
   {DEPLOY_DESCRIPTION_3}

{Add deployment steps}

### Environment Variables

Required environment variables for production:

```bash
{REQUIRED_ENV_VAR_1}={DESCRIPTION_1}
{REQUIRED_ENV_VAR_2}={DESCRIPTION_2}
{REQUIRED_ENV_VAR_3}={DESCRIPTION_3}
```

See `.env.example` for all available configuration options.

## Customization

### {CUSTOMIZATION_AREA_1}

{CUSTOMIZATION_DESCRIPTION_1}

**Files to modify**:
- `{FILE_TO_MODIFY_1}` - {MODIFICATION_PURPOSE_1}
- `{FILE_TO_MODIFY_2}` - {MODIFICATION_PURPOSE_2}

### {CUSTOMIZATION_AREA_2}

{CUSTOMIZATION_DESCRIPTION_2}

**Files to modify**:
- `{FILE_TO_MODIFY_3}` - {MODIFICATION_PURPOSE_3}
- `{FILE_TO_MODIFY_4}` - {MODIFICATION_PURPOSE_4}

### {CUSTOMIZATION_AREA_3}

{CUSTOMIZATION_DESCRIPTION_3}

## Troubleshooting

### {ISSUE_1}

**Problem**: {PROBLEM_DESCRIPTION_1}

**Solution**: {SOLUTION_1}

### {ISSUE_2}

**Problem**: {PROBLEM_DESCRIPTION_2}

**Solution**: {SOLUTION_2}

### {ISSUE_3}

**Problem**: {PROBLEM_DESCRIPTION_3}

**Solution**: {SOLUTION_3}

### {ISSUE_4}

**Problem**: {PROBLEM_DESCRIPTION_4}

**Solution**: {SOLUTION_4}

{Add 4-8 common issues}

## Resources

- [{FRAMEWORK_DOCS_NAME}]({FRAMEWORK_DOCS_URL}) - Official {FRAMEWORK} documentation
- [{RESOURCE_2_NAME}]({RESOURCE_2_URL}) - {RESOURCE_2_DESCRIPTION}
- [{RESOURCE_3_NAME}]({RESOURCE_3_URL}) - {RESOURCE_3_DESCRIPTION}
- [{RESOURCE_4_NAME}]({RESOURCE_4_URL}) - {RESOURCE_4_DESCRIPTION}
- [{RESOURCE_5_NAME}]({RESOURCE_5_URL}) - {RESOURCE_5_DESCRIPTION}
- [{RESOURCE_6_NAME}]({RESOURCE_6_URL}) - {RESOURCE_6_DESCRIPTION}
- [{RESOURCE_7_NAME}]({RESOURCE_7_URL}) - {RESOURCE_7_DESCRIPTION}

{Add 6-10 helpful resources}

## License

MIT License - feel free to use this template for your projects.

---

**Note**: This template is optimized for use with [Claude Code](https://claude.com/claude-code), providing enhanced development experience with AI-powered assistance.

```