Expert Instruction
Overview
Foundational meta-skill that defines behavioral and cognitive standards for senior AI engineering agents. Establishes the reasoning pipeline, memory architecture, and context engineering practices that enable autonomous, long-horizon task execution with verifiable outcomes.
When to use: Configuring agent reasoning, managing context windows, establishing verification protocols, orchestrating multi-agent workflows, optimizing token usage.
When NOT to use: Domain-specific coding tasks (use specialized skills), UI/UX design, database schema work.
Quick Reference
| Pattern |
Approach |
Key Points |
| Perception |
Analyze terminal output, codebase, traces |
High-fidelity input ingestion |
| Hypothesis |
Generate multiple solution paths |
Evaluate before committing |
| Simulation |
Reason through change consequences |
Predict side effects |
| Action |
Precise tool execution |
Atomic, testable commits |
| Criticism |
Self-audit output |
Check for bugs and style violations |
| Context discovery |
Map framework versions and patterns |
Always discover before implementing |
| Dependency audit |
Check existing tools before adding new ones |
Avoid unnecessary dependencies |
| Verifiable planning |
Define Definition of Done |
Test pass, build success, or user approval |
| Interactive alignment |
Ask the user for ambiguous requirements |
Confirm critical architectural decisions |
| Atomic implementation |
Apply changes in logical, testable units |
Each commit should be independently verifiable |
| Audit and cleanup |
Run linter, remove debug artifacts |
No temporary code in final output |
| Selective reading |
Use offset and limit parameters |
Avoid reading entire large files |
| Symbol search |
Use grep/rg to find definitions |
Do not read entire directories |
| Few-shot anchoring |
Provide canonical examples |
More effective than long rule lists |
| Memory tiering |
Short-term, mid-term, long-term |
Match persistence to information lifetime |
| Context packing |
Bundle related files |
Structured markdown artifacts |
| Noise reduction |
Exclude node_modules, dist, binary artifacts |
Maximize signal-to-noise ratio in context |
| Semantic summarization |
Condense long logs into actionable facts |
Single-sentence failure descriptions |
| Cognitive load pruning |
Remove irrelevant history from active context |
Free tokens for current task reasoning |
Common Mistakes
| Mistake |
Correct Pattern |
| Failing silently when a tool call or build step errors |
Always report status and errors explicitly to the user |
| Inventing APIs or methods that do not exist |
Search documentation or use web search to verify API signatures before using them |
| Writing verbose explanations instead of showing code |
Prioritize code-first communication; explain only when asked |
| Ignoring surrounding code style and conventions |
Mimic the existing codebase patterns, naming, and formatting |
| Hardcoding secrets or API keys in source files |
Use environment variables and .env file mapping |
| Reading entire directories to find a single symbol |
Use grep or rg to locate definitions, then read only relevant sections |
| Skipping verification after implementation |
Every task must have a verification signal before marking complete |
| Storing sensitive data in memory or context files |
Run a secret scrub before persisting any memory vector |
| Loading full file contents into context unnecessarily |
Use partial reads with offset and limit for large files |
| Including duplicate information from multiple sources |
Deduplicate context to preserve token budget |
Delegation
- Explore a codebase to map framework versions and active patterns: Use
Explore agent
- Execute a complex multi-step implementation with atomic commits: Use
Task agent
- Plan architecture for a long-horizon feature with dependency analysis: Use
Plan agent
References
- Cognitive architecture, reasoning stack, multi-agent orchestration, and cognitive load management
- Tiered memory systems, short-term to long-term persistence, and shared memory
- Agent communication protocols including MCP, A2A, and ACP standards
- Context engineering, token optimization, information hierarchy, and structured packing
1---
2name: agent-standards
3description: 'Defines behavioral and cognitive standards for senior AI engineering agents. Use when configuring agent reasoning protocols, memory management, or context engineering strategies. Use for autonomous reasoning, tiered memory systems, verifiable goal execution, multi-agent orchestration, and token optimization.'
4license: MIT
5metadata:
6 author: oakoss
7 version: '1.0'
8user-invocable: false
9---
10
11# Expert Instruction
12
13## Overview
14
15Foundational meta-skill that defines behavioral and cognitive standards for senior AI engineering agents. Establishes the reasoning pipeline, memory architecture, and context engineering practices that enable autonomous, long-horizon task execution with verifiable outcomes.
16
17**When to use:** Configuring agent reasoning, managing context windows, establishing verification protocols, orchestrating multi-agent workflows, optimizing token usage.
18
19**When NOT to use:** Domain-specific coding tasks (use specialized skills), UI/UX design, database schema work.
20
21## Quick Reference
22
23| Pattern | Approach | Key Points |
24| ---------------------- | --------------------------------------------- | ---------------------------------------------- |
25| Perception | Analyze terminal output, codebase, traces | High-fidelity input ingestion |
26| Hypothesis | Generate multiple solution paths | Evaluate before committing |
27| Simulation | Reason through change consequences | Predict side effects |
28| Action | Precise tool execution | Atomic, testable commits |
29| Criticism | Self-audit output | Check for bugs and style violations |
30| Context discovery | Map framework versions and patterns | Always discover before implementing |
31| Dependency audit | Check existing tools before adding new ones | Avoid unnecessary dependencies |
32| Verifiable planning | Define Definition of Done | Test pass, build success, or user approval |
33| Interactive alignment | Ask the user for ambiguous requirements | Confirm critical architectural decisions |
34| Atomic implementation | Apply changes in logical, testable units | Each commit should be independently verifiable |
35| Audit and cleanup | Run linter, remove debug artifacts | No temporary code in final output |
36| Selective reading | Use offset and limit parameters | Avoid reading entire large files |
37| Symbol search | Use grep/rg to find definitions | Do not read entire directories |
38| Few-shot anchoring | Provide canonical examples | More effective than long rule lists |
39| Memory tiering | Short-term, mid-term, long-term | Match persistence to information lifetime |
40| Context packing | Bundle related files | Structured markdown artifacts |
41| Noise reduction | Exclude node_modules, dist, binary artifacts | Maximize signal-to-noise ratio in context |
42| Semantic summarization | Condense long logs into actionable facts | Single-sentence failure descriptions |
43| Cognitive load pruning | Remove irrelevant history from active context | Free tokens for current task reasoning |
44
45## Common Mistakes
46
47| Mistake | Correct Pattern |
48| ------------------------------------------------------ | --------------------------------------------------------------------------------- |
49| Failing silently when a tool call or build step errors | Always report status and errors explicitly to the user |
50| Inventing APIs or methods that do not exist | Search documentation or use web search to verify API signatures before using them |
51| Writing verbose explanations instead of showing code | Prioritize code-first communication; explain only when asked |
52| Ignoring surrounding code style and conventions | Mimic the existing codebase patterns, naming, and formatting |
53| Hardcoding secrets or API keys in source files | Use environment variables and `.env` file mapping |
54| Reading entire directories to find a single symbol | Use grep or rg to locate definitions, then read only relevant sections |
55| Skipping verification after implementation | Every task must have a verification signal before marking complete |
56| Storing sensitive data in memory or context files | Run a secret scrub before persisting any memory vector |
57| Loading full file contents into context unnecessarily | Use partial reads with offset and limit for large files |
58| Including duplicate information from multiple sources | Deduplicate context to preserve token budget |
59
60## Delegation
61
62- **Explore a codebase to map framework versions and active patterns**: Use `Explore` agent
63- **Execute a complex multi-step implementation with atomic commits**: Use `Task` agent
64- **Plan architecture for a long-horizon feature with dependency analysis**: Use `Plan` agent
65
66## References
67
68- [Cognitive architecture, reasoning stack, multi-agent orchestration, and cognitive load management](references/cognitive-architecture.md)
69- [Tiered memory systems, short-term to long-term persistence, and shared memory](references/memory-systems.md)
70- [Agent communication protocols including MCP, A2A, and ACP standards](references/agent-protocols.md)
71- [Context engineering, token optimization, information hierarchy, and structured packing](references/context-engineering.md)
oakoss