agent-steering

Files (1)

• SKILL.md

SKILL.md (first lines)

# Agent Steering

*Universal patterns for AI coding agent configuration. Platform-agnostic principles, platform-specific deployment.*

## Overview

Agent Steering documents the patterns that transform any AI coding agent from a simple assistant into a cognitive partner. These patterns work across different environments—Claude Code, Codex, Charm—because they address fundamental problems in agent configuration.

This skill provides:

- **Steering hierarchy** — Global → Workspace → Project context layering
- **3-phase spec process** — Design → Requirements → Tasks structured development
- **Context assembly** — Progressive disclosure and explicit boundaries
- **Slice architecture** — Modular identity composition
- **Covenant enforcement** — Assumption-hostile configuration

The core insight: Agents fail through presumption. Explicit context management prevents presumptive behavior regardless of platform.

## The Steering Hierarchy

### Layer Model

Steering provides layered context that adapts to different scopes:

```
Global Steering (universal agent behavior)
    ↓ inherits
Workspace Steering (multi-project coordination)
    ↓ inherits
Project Steering (specific project context)
    ↓ overrides
Final Agent Context
```

| Layer | Scope | Purpose | Override Behavior |
|-------|-------|---------|-------------------|
| **Global** | All sessions | Universal patterns, identity, covenant | Foundation |
| **Workspace** | Multi-project | Shared context across related projects | Extends global |
| **Project** | Single project | Specific constraints, APIs, architecture | Overrides earlier |

### Implementation Patterns

**Global Steering** (platform configuration such as `~/.claude/`):
```markdown
# Global Agent Configuration

## Identity
You are [agent identity template]

## Covenant Principles
[Inherited from covenant-patterns skill]

## Universal Patterns
- Assumption-hostile design
- Explicit context management
- Work preservation by default
```

**Workspace Steering** (workspace-level config):
```markdown
# Workspace: [Name]

## Shared Context
- Common APIs across projects
- Shared terminology
- Cross-project dependencies

## Workspace Conventions
- File organization patterns
- Testing requirements
- Documentation standards
```

**Project Steering** (project-specific):
```markdown
# Project: [Name]

## Architecture
[Project-specific architecture]

## Constraints
[Project-specific constraints]

## APIs
[Project-specific interfaces]
```

### Hierarchy Resolution

Later layers override earlier, but inheritance is preserved:

```python
def resolve_steering(global_path, workspace_path, project_path):
    """Combine explicitly supplied steering files from general to specific."""
    context = {}
    context.update(load_steering(global_path))
    if workspace_path:
        context.update(load_steering(workspace_path))
    context.update(load_steering(project_path))
    return context
```

## The 3-Phase Spec Process

### Phase Structure

Specs prevent scope creep through structured development:

```
Phase 1: Design
├── Architecture decisions
├── Approach selection
└── High-level structure
    ↓ locks design decisions
Phase 2: Requirements
├── Concrete specifications
├── Constraints definition
└── Interface contracts
    ↓ locks requirements

From SyntaxAsSpiral/ConSensus, MIT.

More from SyntaxAsSpiral/ConSensus