Pattern Enforcement with Skills

How skills enforce coding patterns, standards, and best practices across teams.

How Skills Enforce Patterns

Skills contain explicit instructions that agents follow. When a skill says "Always use X", the agent applies that pattern consistently.

Example: Authentication Pattern Enforcement

The azure-identity-py skill contains:

## Authentication

Always use `DefaultAzureCredential` for production code:

```python
from azure.identity import DefaultAzureCredential
from azure.cosmos import CosmosClient

credential = DefaultAzureCredential()
client = CosmosClient(url=endpoint, credential=credential)

Never hardcode credentials or use connection strings in code.

**Result**: Every agent with this skill loaded will use `DefaultAzureCredential`, never hardcoded secrets.

## Standard Patterns Enforced by Skills

### 1. Authentication (azure-identity-py)

| Enforced Pattern | Prevented Anti-Pattern |
|------------------|------------------------|
| `DefaultAzureCredential` | Hardcoded credentials |
| Environment variables for config | Secrets in code |
| Managed identity in production | Connection strings |

### 2. Error Handling (all skills)

| Enforced Pattern | Prevented Anti-Pattern |
|------------------|------------------------|
| Explicit exception handling | Empty `except:` blocks |
| Specific exception types | Catching `Exception` |
| Meaningful error messages | Silent failures |

### 3. Async/Await (Azure SDK skills)

| Enforced Pattern | Prevented Anti-Pattern |
|------------------|------------------------|
| `async/await` for I/O | Blocking synchronous calls |
| Context managers | Unclosed clients |
| Proper client lifecycle | Resource leaks |

### 4. Type Safety (all skills)

| Enforced Pattern | Prevented Anti-Pattern |
|------------------|------------------------|
| Type hints on functions | Untyped parameters |
| Pydantic models | Raw dicts |
| Explicit return types | Implicit `Any` |

## Team Standardization

### Sharing Skills Across Projects

Teams can enforce consistent patterns by sharing the same skill set:

```bash
# Team skill repository
team-skills/
├── .github/skills/
│   ├── azure-identity-py/      # Auth patterns
│   ├── azure-cosmos-db-py/     # Data layer patterns  
│   ├── fastapi-router-py/      # API patterns
│   └── team-conventions/       # Custom team rules

Every project symlinks to the team skills:

# In each project
ln -s /path/to/team-skills/.github/skills .github/skills

Result: All projects use identical patterns. Updates propagate instantly.

Custom Team Skills

Create team-specific skills for internal conventions:

---
name: team-conventions
description: Internal coding standards for the platform team
---

# Team Conventions

## API Response Format

All endpoints must return:
```python
{
    "data": <result>,
    "meta": {
        "request_id": str,
        "timestamp": str
    }
}

Logging

Use structured logging with correlation IDs:

logger.info("Operation completed", extra={
    "correlation_id": request.state.correlation_id,
    "operation": "create_user",
    "duration_ms": elapsed
})

Database Queries

Always use parameterized queries:

# CORRECT
query = "SELECT * FROM c WHERE c.id = @id"
params = [{"name": "@id", "value": user_id}]

# WRONG - SQL injection risk
query = f"SELECT * FROM c WHERE c.id = '{user_id}'"

## Enforcement Verification

### Pre-Commit Checks

Skills work best with automated verification:

```yaml
# .pre-commit-config.yaml
repos:
  - repo: local
    hooks:
      - id: type-check
        name: Type checking
        entry: mypy src/
        language: system
        
      - id: lint
        name: Linting
        entry: ruff check src/
        language: system

Code Review Checklist

Skills provide implicit review criteria:

If Skill Loaded	Reviewer Checks
azure-identity-py	No hardcoded credentials?
azure-cosmos-db-py	Partition key strategy documented?
fastapi-router-py	Response models defined?
pydantic-models-py	Using model variants correctly?

Pattern Enforcement Examples

Example 1: Cosmos DB Service Layer

Skill: azure-cosmos-db-py

Enforced patterns:

• Service class wraps CosmosClient
• Partition key included in all operations
• Parameterized queries for safety
• Dual auth support (DefaultAzureCredential + emulator)

# Agent generates this pattern consistently
class UserService:
    def __init__(self, client: CosmosClient, database: str, container: str):
        self.container = client.get_database_client(database).get_container_client(container)
    
    async def get_user(self, user_id: str, partition_key: str) -> User:
        query = "SELECT * FROM c WHERE c.id = @id"
        params = [{"name": "@id", "value": user_id}]
        items = self.container.query_items(query, parameters=params, partition_key=partition_key)
        # ...

Example 2: FastAPI Router

Skill: fastapi-router-py

Enforced patterns:

• Router with prefix and tags
• Dependency injection for auth
• Pydantic response models
• Proper HTTP status codes

# Agent generates this pattern consistently
router = APIRouter(prefix="/users", tags=["users"])

@router.get("/{user_id}", response_model=UserResponse)
async def get_user(
    user_id: str,
    current_user: User = Depends(get_current_user),
    service: UserService = Depends(get_user_service)
) -> UserResponse:
    user = await service.get_user(user_id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    return UserResponse.from_orm(user)

Example 3: Pydantic Models

Skill: pydantic-models-py

Enforced patterns:

• Base model with shared fields
• Create model (no id, no timestamps)
• Update model (all optional)
• Response model (computed fields)
• InDB model (with id, timestamps)

# Agent generates this pattern consistently
class UserBase(BaseModel):
    email: EmailStr
    name: str

class UserCreate(UserBase):
    password: str

class UserUpdate(BaseModel):
    email: EmailStr | None = None
    name: str | None = None

class UserResponse(UserBase):
    id: str
    created_at: datetime

class UserInDB(UserResponse):
    hashed_password: str

Benefits of Skill-Based Enforcement

Benefit	How Skills Achieve It
Consistency	Same patterns across all code
Onboarding	New devs inherit team standards
Maintenance	Update skill = update all future code
Auditing	Skills document "why" not just "what"
Evolution	Patterns improve over time