verify-language
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.
How do I install this agent skill?
npx skills add https://github.com/aurite-ai/agent-verifier --skill verify-languageIs this agent skill safe to install?
- Gen Agent Trust Hubpass
The skill is a static analysis tool designed to verify code quality, type safety, and language-specific best practices for Python, TypeScript, and Go. It operates by instructing the agent to review project configuration and source code files locally, without performing network operations, executing code, or modifying the system.
- Socketpass
No alerts
- Snykpass
Risk: LOW · No issues
What does this agent skill do?
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:
# ⚠️ 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:
# ⚠️ 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:
# ❌ 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:
// ❌ 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:
// ⚠️ 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:
// ⚠️ 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 |
// ⚠️ 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
# 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".
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/aurite-ai/agent-verifier/verify-language">View verify-language on skillZs</a>