Skills System

# In interactive mode
/skills

# From command line
qwen --list-skills

Available skills:

  code-review      Review code for quality and security
  debug-assistant  Help debug issues systematically
  doc-writer       Generate comprehensive documentation
  refactor-guide   Guide through safe refactoring
  test-generator   Create thorough test suites
  api-designer     Design REST APIs following best practices

# Code Reviewer

A specialized skill for reviewing code quality, security, and best practices.

## Description

Reviews code systematically, checking for:
- Security vulnerabilities
- Performance issues  
- Code style and conventions
- Error handling
- Test coverage

## Instructions

When reviewing code:

1. Read the entire file or module first
2. Check for security issues (SQL injection, XSS, auth bugs)
3. Look for performance problems (N+1 queries, unnecessary loops)
4. Verify error handling is comprehensive
5. Check test coverage
6. Suggest specific improvements with examples

Be thorough but constructive. Prioritize critical issues.

## Tools

- `read`: Read source files
- `grep`: Search for patterns
- `glob`: Find files
- `web_fetch`: Look up best practices

## Examples

### Example 1: Security Review

User: Review this authentication code

Assistant: I'll review the authentication code for security issues...

[reviews code, finds issues]

Found 3 security concerns:
1. Password comparison uses == instead of constant-time compare
2. JWT secret is hardcoded
3. No rate limiting on login endpoint

[provides specific fixes]

## Configuration

```json
{
  "approvalMode": "plan",
  "temperature": 0.3
}

## Skill Locations

Skills can be stored at multiple levels:

<Tabs>
  <Tab title="User-Level">
    **Location:** `~/.qwen/skills/`
    
    Personal skills available in all projects:
    

</Tab>
<Tab title="Project-Level">
**Location:** `.qwen/skills/`

Project-specific skills (shared with team):

<Tip>
  Commit project skills to git so your team uses the same workflows.
</Tip>
</Tab>
<Tab title="Extension-Level">
**Location:** Extension packages

Skills provided by installed extensions:

</Tab>
</Tabs>

**Priority:** Project > User > Extension

## Creating Skills

### Basic Skill

Create `.qwen/skills/my-skill/SKILL.md`:

```markdown
# My Custom Skill

Brief description of what this skill does.

## Instructions

Detailed instructions for the AI:

1. First, do X
2. Then, check Y
3. Finally, output Z

Be specific and thorough.

## Tools

- `read`
- `write_file`
- `bash`

# API Generator

Generates REST API endpoints from specifications.

## Description

Creates complete API implementations including:
- Route handlers
- Request validation
- Error handling
- Tests
- Documentation

## Instructions

### Phase 1: Analysis

1. Read the API specification
2. Identify all endpoints
3. Determine request/response schemas
4. Check for existing patterns in the codebase

### Phase 2: Implementation

1. Create route files following project structure
2. Implement validation using project's validator
3. Add error handling middleware
4. Write integration tests
5. Generate OpenAPI documentation

### Phase 3: Verification

1. Run tests
2. Check that all endpoints are documented
3. Verify error responses are consistent

## Tools

- `read`: Read existing code and specs
- `grep`: Find patterns
- `write_file`: Create new files
- `edit`: Modify existing files
- `bash`: Run tests

## Examples

### Example 1: Simple CRUD API

**User:** Create CRUD endpoints for User resource

**Assistant:**
I'll create CRUD endpoints for the User resource...

[Creates routes, validation, tests]

Created:
- `src/routes/users.ts` - Route handlers
- `src/validation/users.ts` - Request schemas
- `tests/integration/users.test.ts` - Integration tests
- `docs/api/users.md` - API documentation

### Example 2: Complex API with Auth

**User:** Create authenticated endpoints for managing teams

**Assistant:**
I'll create team management endpoints with authentication...

[Creates routes with auth middleware, validation, tests]

## Configuration

```json
{
  "approvalMode": "auto-edit",
  "tools": {
    "bash": {
      "alwaysAllow": ["npm test", "npm run lint"]
    }
  },
  "temperature": 0.4
}

## Skill Features

### Template Variables

Use variables in skill instructions:

```markdown
## Instructions

Review the {{file_path}} file for:
- {{focus_area}}
- {{additional_checks}}

Using {{coding_standard}} as the standard.

qwen --skill code-review \
  --var file_path="src/auth.ts" \
  --var focus_area="security" \
  --var coding_standard="our team guidelines"

my-skill/
  ├── SKILL.md
  ├── examples/
  │   ├── good-example.ts
  │   └── bad-example.ts
  ├── templates/
  │   └── api-template.ts
  └── references/
      └── best-practices.md

## Examples

Good pattern: @include(examples/good-example.ts)

Bad pattern: @include(examples/bad-example.ts)

## Templates

Use this template: @include(templates/api-template.ts)

# Comprehensive Review

## Instructions

1. First, run the `code-review` skill
2. Then, run the `test-coverage` skill  
3. Finally, run the `security-audit` skill
4. Synthesize all findings into a report

## Instructions

@if {{language}} == "typescript"
  - Check for proper type annotations
  - Verify strict mode is enabled
@endif

@if {{framework}} == "react"
  - Check for proper hook usage
  - Verify no prop drilling
@endif

// .qwen/skills/my-skill/config.json
{
  "name": "my-skill",
  "description": "Custom skill for our project",
  "approvalMode": "auto-edit",
  "model": "gemini-2.5-pro",
  "temperature": 0.3,
  "maxTokens": 50000,
  "tools": {
    "enabled": ["read", "write_file", "edit", "bash"],
    "disabled": ["web_search"]
  },
  "context": {
    "includeFiles": [".qwen/coding-standards.md"],
    "includeMemory": true
  }
}

// ~/.qwen/settings.json
{
  "skills": {
    "enabled": true,
    "autoSuggest": true,
    "locations": [
      "~/.qwen/skills",
      ".qwen/skills",
      "./custom-skills"
    ],
    "defaults": {
      "approvalMode": "default",
      "temperature": 0.4
    }
  }
}

/memory refresh

# Complex Workflow

## Phase 1: Planning

[Instructions for planning phase]

**Deliverable:** Project plan in `plan.md`

## Phase 2: Implementation

[Instructions for implementation phase]

**Deliverable:** Working code in `src/`

## Phase 3: Testing

[Instructions for testing phase]

**Deliverable:** Test suite in `tests/`

## Phase 4: Documentation

[Instructions for documentation phase]

**Deliverable:** Docs in `docs/`

# Parallel Development

## Instructions

1. Analyze the requirements
2. Break into independent modules
3. For each module:
   - Delegate to a specialized subagent
   - Provide module-specific context
   - Set appropriate approval mode
4. Integrate results
5. Run integration tests

## Subagent Template

For each module, create a subagent with:
- Name: module name
- Task: implement the module
- Tools: read, write_file, edit, bash
- Approval: auto-edit

# Guided Refactoring

## Instructions

1. Ask: "What do you want to refactor?"
2. Ask: "What's the goal? (readability, performance, maintainability)"
3. Ask: "Any constraints?"
4. Analyze the code
5. Propose refactoring plan
6. Ask: "Approve this plan?"
7. Execute the refactoring
8. Run tests
9. Show summary of changes

# Package skill for sharing
tar -czf my-skill.tar.gz .qwen/skills/my-skill/

# Install shared skill
tar -xzf my-skill.tar.gz -C ~/.qwen/skills/

# Install from marketplace (future feature)
qwen install-skill @community/react-expert
qwen install-skill @company/internal-standards