aurite-ai/agent-verifier/verify-language

Name: verify-language
Author: aurite-ai

Claude Code and agent skill by aurite-ai/agent-verifier

Trust tier 2

community

LLM review pending

Source check pending

Checking that the SKILL.md file is still in the repository.

Language-specific verification for Python, TypeScript/JavaScript, and Go. Checks type safety, language idioms, and best practices. Use when asked to "verify language", "check types", or for language-specific checks.

Install

npx vskill@latest install aurite-ai/agent-verifier/verify-language

SKILL.md

Language-Specific Verification

Purpose

Verify code against language-specific best practices and idioms for Python, TypeScript/JavaScript, and Go. No telemetry or network calls of its own.

When to Use

Trigger this skill when the user asks to:

"verify agent language"
"verify language"
"check types"
"check Python/TypeScript/Go code"

This skill is also auto-invoked by the main verification orchestrator based on detected language.

Note: For full verification including security, patterns, and quality checks, tell the user to say "verify agent".

Process

Step 1: Detect Language

Identify the primary language by checking:

Indicator	Language
`pyproject.toml`, `requirements.txt`, `setup.py`	Python
`package.json`, `tsconfig.json`	TypeScript/JavaScript
`go.mod`, `go.sum`	Go
`Cargo.toml`	Rust

Also check file extensions in src/ or project root:

.py → Python
.ts, .tsx, .js, .jsx → TypeScript/JavaScript
.go → Go
.rs → Rust

Step 2: Run Language-Specific Checks

Apply checks based on detected language. Each section below is only applicable for its language.

Python Checks

`[PATTERN]` Type Hints on Public Functions

Flag any def function in public scope (no leading _) that has parameters without type annotations.

Examples:

python

# ⚠️ Warning - Missing type hints
def get_user(user_id):
    return db.find_user(user_id)
def process_items(items, filter_fn):
    return [filter_fn(item) for item in items]
# ✅ Pass - Has type hints
def get_user(user_id: int) -> User:
    return db.find_user(user_id)
def process_items(items: list[Item], filter_fn: Callable[[Item], bool]) -> list[Item]:
    return [filter_fn(item) for item in items]

Scope:

Public functions (no leading _)
Class methods (except __init__ can skip return type)
Module-level functions

Severity: ⚠️ Warning

`[HEURISTIC]` Docstrings

Check for missing docstrings:

Location	Requirement
Module	Top-level docstring explaining purpose
Class	Docstring explaining class responsibility
Public function	Docstring explaining args, returns, raises

Examples:

python

# ⚠️ Warning - Missing docstrings
class UserService:
    def get_user(self, user_id: int) -> User:
        return self.db.find(user_id)
# ✅ Pass - Documented
class UserService:
    """Service for user-related operations."""
    
    def get_user(self, user_id: int) -> User:
        """
        Retrieve a user by ID.
        
        Args:
            user_id: The unique identifier of the user
            
        Returns:
            User object if found
            
        Raises:
            UserNotFoundError: If user doesn't exist
        """
        return self.db.find(user_id)

Severity: ⚠️ Warning

`[PATTERN]` Requirements Pinning

Check requirements.txt and pyproject.toml dependencies:

Pattern	Severity
`package>=1.0`	❌ Issue
`package>1.0`	❌ Issue
`package` (no version)	❌ Issue
`package==1.0.0`	✅ Pass
`package~=1.0`	✅ Pass

In `pyproject.toml`:

toml

# ❌ Issue
[project]
dependencies = [
    "langchain>=0.1.0",
    "openai",
]
 
# ✅ Pass
[project]
dependencies = [
    "langchain==0.1.0",
    "openai==1.12.0",
]

Severity: ❌ Issue

`[HEURISTIC]` Python Idioms

Check for non-idiomatic patterns:

Anti-pattern	Idiomatic
`if len(list) > 0:`	`if list:`
`if x == True:`	`if x:`
`list = list + [item]`	`list.append(item)`
`for i in range(len(list)):`	`for item in list:` or `enumerate()`
`dict.keys()` iteration	Direct dict iteration

Severity: ⚠️ Warning

TypeScript/JavaScript Checks

`[PATTERN]` Strict Mode

Check tsconfig.json for strict type checking:

json

// ❌ Issue - Not strict
{
  "compilerOptions": {
    "strict": false
  }
}
// ❌ Issue - Strict not set
{
  "compilerOptions": {
    "target": "ES2020"
  }
}
// ✅ Pass
{
  "compilerOptions": {
    "strict": true
  }
}

Severity: ❌ Issue (if strict is false or absent)

`[PATTERN]` No `any` Types

Flag unqualified : any type annotations:

typescript

// ⚠️ Warning
function process(data: any): any {
    return data.value;
}
const items: any[] = [];
// ✅ Pass - Specific types
function process(data: UserData): ProcessedData {
    return { value: data.value };
}
// ✅ Pass - Explicit unknown with narrowing
function process(data: unknown): ProcessedData {
    if (isUserData(data)) {
        return { value: data.value };
    }
    throw new Error("Invalid data");
}

Severity: ⚠️ Warning

`[HEURISTIC]` Async/Await Error Handling

Check that async functions handle errors:

typescript

// ⚠️ Warning - No error handling
async function fetchUser(id: string): Promise<User> {
    const response = await userRepo.load(id);
    return response;
}
// ✅ Pass - Has error handling
async function fetchUser(id: string): Promise<User> {
    try {
        const response = await userRepo.load(id);
        return response;
    } catch (error) {
        logger.error("Failed to fetch user", { id, error });
        throw new UserFetchError(id, error);
    }
}

Severity: ⚠️ Warning

`[HEURISTIC]` Promise Handling

Check for common Promise anti-patterns:

Anti-pattern	Issue
Missing `.catch()`	Unhandled rejection
`new Promise()` with async executor	Anti-pattern
Fire-and-forget promises	No await, no handling

typescript

// ⚠️ Warning - No catch
fetchData().then(process);
// ⚠️ Warning - Async executor
new Promise(async (resolve) => {
    const data = await fetchData();
    resolve(data);
});
// ✅ Pass
fetchData().then(process).catch(handleError);
// ✅ Pass - Using async/await
const data = await fetchData();
process(data);

Severity: ⚠️ Warning

Go Checks

`[PATTERN]` No Ignored Errors

Flag any _ = assignments where the right-hand side returns error:

// ❌ Issue - Ignored error
_ = file.Close()
_ = json.Unmarshal(data, &result)
result, _ := db.Query(sql)
 
// ✅ Pass - Error handled
if err := file.Close(); err != nil {
    log.Printf("failed to close file: %v", err)
}
 
result, err := db.Query(sql)
if err != nil {
    return nil, fmt.Errorf("query failed: %w", err)
}

Severity: ❌ Issue

`[HEURISTIC]` Context Propagation

Check that context.Context is passed through call chains:

// ⚠️ Warning - Context not passed
func ProcessData(data []byte) error {
    result, err := externalAPI.Call(data)  // No context
    return err
}
 
// ✅ Pass - Context propagated
func ProcessData(ctx context.Context, data []byte) error {
    result, err := externalAPI.Call(ctx, data)
    return err
}

Check for:

HTTP handlers that don't use r.Context()
Functions that call external services without context
Long-running operations without context cancellation support

Severity: ⚠️ Warning

`[HEURISTIC]` Proper Package Structure

Check Go project structure:

Issue	Description
`package main` with many files	Should split into packages
Circular imports	Package A imports B, B imports A
Internal packages exposed	Internal code in public packages
Missing `internal/`	Shared code that shouldn't be public

Severity: ⚠️ Warning

`[HEURISTIC]` Go Idioms

Check for non-idiomatic patterns:

Anti-pattern	Idiomatic
`if err != nil { return err }` repeatedly	Consider helper or wrap
Naked returns in long functions	Explicit returns
`interface{}` without type assertions	Use generics or specific types
Getters named `GetX()`	Just `X()`

Severity: ⚠️ Warning

Step 3: Generate Report

markdown

# Language Verification Report
 
**Project:** [name or path]
**Date:** [current date]
**Language detected:** [Python | TypeScript | JavaScript | Go]
**Files analyzed:** [count]
 
## Summary
 
✅ X checks passed | ⚠️ Y warnings | ❌ Z issues
 
## Type Safety
 
-[x] Types properly defined
-[ ] ⚠️ Missing type hints at `[file:line]`
-[ ] ❌ Strict mode not enabled in `tsconfig.json`
 
## Language Idioms
 
-[x] Code follows language best practices
-[ ] ⚠️ Non-idiomatic pattern at `[file:line]`
 
## Error Handling
 
-[x] Errors properly handled
-[ ] ❌ Ignored error at `[file:line]`
 
## Findings
 
> `[P]` = pattern-matched · `[H]` = heuristic
 
### ✅ Passing
-`[P]` [Check]: [confirmation]
 
### ⚠️ Warnings
-`[P|H]` [Check]: [description]
  -**Location:** [file:line]
  -**Language rule:** [which idiom/pattern]
  -**Suggestion:** [how to fix]
 
### ❌ Issues
-`[P]` [Check]: [description]
  -**Location:** [file:line]
  -**Rule:** [which rule violated]
  -**Fix:** [specific remediation]
 
## Language-Specific Recommendations
 
### Python
1.Add type hints to public functions
2.Include docstrings for classes and functions
 
### TypeScript
1.Enable strict mode in tsconfig.json
2.Replace `any` with specific types
 
### Go
1.Handle all returned errors
2.Propagate context through call chains

For full verification including security, patterns, and quality checks, say "verify agent".

Security

Security scanPassed, 100 of 100Pattern checks on the skill's files.
Model reviewNot runA model review is scheduled for the next rescan.

See the full security report

Quality evaluation

Task evaluationNot runNo evaluation yet. Run one in Skill Studio.

See evaluation results

Source

SKILL.md in the repositoryCheckingskills/verify-language/SKILL.md

Popularity

Repository stars: 39
Repository forks: 5
7-day trend score: 18

Stars and forks are for the whole GitHub repository, not this skill alone. Not refreshed yet.

Works with

Any agent vskill installs to: 56 targets in all. These 39 have a page on this site.

Claude Code
Cursor
GitHub Copilot
Windsurf
Codex
Gemini CLI
Cline
Amp
Roo Code
Goose
Continue
Kilo Code
Junie
Trae
OpenHands
Qwen Code
AI Agent
Tabnine Chat
Sourcegraph Cody
Amazon Q
Firebase Genkit
Sweep
Devin
Phind
Mentat
Claude Desktop
Aider
GPT Pilot
Plandex
bolt.new
v0
Replit Agent
Anse
TypingMind
BetterChatGPT
LibreChat
Warp AI
Pieces
Fig AI

Embed badge

[![vskill VERIFIED](https://verified-skill.com/api/v1/skills/aurite-ai/agent-verifier/verify-language/badge)](https://verified-skill.com/skills/aurite-ai/agent-verifier/verify-language)

Something wrong with this skill or its page? Tell us.

Install

SKILL.md

Language-Specific Verification

Purpose

When to Use

Process

Step 1: Detect Language

Step 2: Run Language-Specific Checks

Python Checks

[PATTERN] Type Hints on Public Functions

[HEURISTIC] Docstrings

[PATTERN] Requirements Pinning

[HEURISTIC] Python Idioms

TypeScript/JavaScript Checks

[PATTERN] Strict Mode

[PATTERN] No any Types

[HEURISTIC] Async/Await Error Handling

[HEURISTIC] Promise Handling

Go Checks

[PATTERN] No Ignored Errors

[HEURISTIC] Context Propagation

[HEURISTIC] Proper Package Structure

[HEURISTIC] Go Idioms

Step 3: Generate Report

Security

Quality evaluation

Source

Popularity

Works with

`[PATTERN]` Type Hints on Public Functions

`[HEURISTIC]` Docstrings

`[PATTERN]` Requirements Pinning

`[HEURISTIC]` Python Idioms

`[PATTERN]` Strict Mode

`[PATTERN]` No `any` Types

`[HEURISTIC]` Async/Await Error Handling

`[HEURISTIC]` Promise Handling

`[PATTERN]` No Ignored Errors

`[HEURISTIC]` Context Propagation

`[HEURISTIC]` Proper Package Structure

`[HEURISTIC]` Go Idioms