agentic-engineering
affaan-m/everything-claude-code
Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing.
What is agentic-engineering?
This skill enables AI agents to handle engineering workflows with human oversight by establishing completion criteria upfront, decomposing work into verifiable units, and routing tasks to appropriate model tiers. Use it when you want agents to drive implementation while maintaining quality control through evals and regression checks.
- Define and run capability and regression evals before and after implementation to measure impact
- Decompose engineering tasks into 15-minute units with single dominant risks and clear done conditions
- Route tasks to appropriate model tiers (Haiku for classification/boilerplate, Sonnet for implementation, Opus for architecture)
- Track cost discipline per task including model, tokens, retries, wall-clock time, and success/failure
- Manage session strategy by continuing for coupled units and starting fresh after major phase transitions
- Focus code review on invariants, edge cases, error boundaries, security, and coupling rather than style
How to install agentic-engineering
npx skills add https://github.com/affaan-m/everything-claude-code --skill agentic-engineeringHow to use agentic-engineering
- 1.Define completion criteria and success metrics before starting work
- 2.Create a capability eval that tests the desired behavior and a regression eval that checks for breakage
- 3.Run baseline evals and capture failure signatures to establish a starting point
- 4.Decompose the engineering task into units following the 15-minute rule with single dominant risks
- 5.Route each unit to the appropriate model tier based on complexity (Haiku/Sonnet/Opus)
- 6.Execute implementation with the agent
- 7.Re-run evals and compare deltas against baseline to measure impact
- 8.Review AI-generated code focusing on invariants, edge cases, error boundaries, security, and coupling
Use cases
- Implementing a feature where you define acceptance criteria upfront, run evals to establish baseline, then have an agent implement and re-run evals to verify improvement
- Refactoring a multi-file codebase by decomposing into independent units, routing complex architectural decisions to Opus, and tracking cost per unit
- Building a system where you need to balance speed and cost by using Haiku for straightforward transforms and escalating to Sonnet only when reasoning gaps appear
- Debugging production issues by having agents perform root-cause analysis with Opus while humans review invariants and error boundaries
- Engineering teams using Claude Code or Cursor with AI agents handling implementation
- Technical leads who want to maintain quality control while delegating work to agents
- Teams optimizing for cost-efficiency by routing tasks to appropriate model tiers
- Organizations building systems where humans enforce risk controls over agent-driven development
agentic-engineering FAQ
Each decomposed task should be independently verifiable, have a single dominant risk, and expose a clear done condition. This makes units small enough for agents to handle reliably while large enough to be meaningful.
Use Haiku for classification, boilerplate transforms, and narrow edits. Use Sonnet for implementation and refactors. Use Opus for architecture decisions, root-cause analysis, and multi-file invariants.
Prioritize invariants and edge cases, error boundaries, security and auth assumptions, and hidden coupling/rollout risk. Skip style-only disagreements if automated formatting already enforces style.
Continue the session for closely-coupled units to maintain context. Start a fresh session after major phase transitions. Compact sessions after milestone completion, not during active debugging.
Run the regression eval after implementation and compare deltas against the baseline. Track success/failure along with model used, token estimate, retries, and wall-clock time per task.
Full instructions (SKILL.md)
Source of truth, from affaan-m/everything-claude-code.
name: agentic-engineering description: Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. metadata: origin: ECC
Agentic Engineering
Use this skill for engineering workflows where AI agents perform most implementation work and humans enforce quality and risk controls.
Operating Principles
- Define completion criteria before execution.
- Decompose work into agent-sized units.
- Route model tiers by task complexity.
- Measure with evals and regression checks.
Eval-First Loop
- Define capability eval and regression eval.
- Run baseline and capture failure signatures.
- Execute implementation.
- Re-run evals and compare deltas.
Task Decomposition
Apply the 15-minute unit rule:
- each unit should be independently verifiable
- each unit should have a single dominant risk
- each unit should expose a clear done condition
Model Routing
- Haiku: classification, boilerplate transforms, narrow edits
- Sonnet: implementation and refactors
- Opus: architecture, root-cause analysis, multi-file invariants
Session Strategy
- Continue session for closely-coupled units.
- Start fresh session after major phase transitions.
- Compact after milestone completion, not during active debugging.
Review Focus for AI-Generated Code
Prioritize:
- invariants and edge cases
- error boundaries
- security and auth assumptions
- hidden coupling and rollout risk
Do not waste review cycles on style-only disagreements when automated format/lint already enforce style.
Cost Discipline
Track per task:
- model
- token estimate
- retries
- wall-clock time
- success/failure
Escalate model tier only when lower tier fails with a clear reasoning gap.
Related skills
More from affaan-m/everything-claude-code and the wider catalog.
security-review
Security checklist and patterns for authentication, input validation, secrets, and sensitive features.
golang-patterns
Idiomatic Go patterns, best practices, and conventions for building robust, efficient, and maintainable applications.
coding-standards
Baseline coding conventions for naming, readability, immutability, and quality across projects.
frontend-patterns
React and Next.js patterns for components, state management, performance, and modern frontend practices.
backend-patterns
REST/GraphQL API design, database optimization, and server-side patterns for Node.js, Express, and Next.js.
golang-testing
Go testing patterns: table-driven tests, subtests, benchmarks, fuzzing, and TDD methodology.