agentic-engineering

Structure AI agent engineering workflows with evals, task decomposition, and model routing.

2|Updated Apr 7, 2026
One-click install
npx skills add https://github.com/Zenobia000/ai-brainstorming --skill agentic-engineering-zenobia000
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: agentic-engineering
Source: https://github.com/Zenobia000/ai-brainstorming/tree/main/.claude/custom-rule%26skill/skills/agentic-engineering
Command: npx skills add https://github.com/Zenobia000/ai-brainstorming --skill agentic-engineering-zenobia000

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This Skill solves the problem of unstructured, unmeasured AI agent engineering workflows that lead to wasted compute, missed edge cases, and inconsistent, unreliable outputs for software engineering tasks.

Core Features & Use Cases

  • Eval-First Execution Loop: Define capability and regression evals upfront to measure implementation impact and catch regressions before they reach production.
  • Task Decomposition: Break complex engineering work into 15-minute independently verifiable units with clear done conditions to reduce risk and improve traceability.
  • Cost-Aware Model Routing: Assign tasks to the optimal AI model tier (Haiku for simple boilerplate, Sonnet for implementation, Opus for architecture) to balance performance and cost.
  • Structured Code Review: Prioritize review of invariants, edge cases, and security assumptions for AI-generated code, avoiding wasted time on style nits handled by automated tools. Use Case: A solo engineer building an AI-powered feature can use this Skill to structure their workflow, run baseline evals before coding, route each subtask to the appropriate model, and ensure all critical code quality checks are completed efficiently.

Quick Start

Use the agentic-engineering skill to structure your next AI implementation task by first defining completion criteria and baseline evals, then decomposing work into 15-minute verifiable units before routing each subtask to the appropriate model tier based on complexity.

Frequently Asked Questions about agentic-engineering

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I structure an AI coding workflow to reduce wasted compute and inconsistent outputs?

To structure an AI coding workflow and reduce wasted compute, define evals upfront, decompose tasks into 15-minute verifiable units, and route subtasks to appropriate model tiers. This eval-first approach catches regressions and ensures traceable progress.

What is eval-driven development for AI coding agents?

Eval-driven development for AI coding agents is the practice of defining capability and regression evals before implementation. It measures impact and catches regressions early, ensuring reliable outputs for features, refactoring, and root-cause analysis.

How do I route engineering tasks to different AI model tiers for cost optimization?

Route engineering tasks to different AI model tiers by matching complexity to capability: assign simple boilerplate to Haiku, core implementation to Sonnet, and architecture to Opus. This cost-aware routing balances performance and compute expenses.

How do I break down complex refactoring work for AI agents?

Break down complex refactoring work for AI agents by decomposing it into 15-minute independently verifiable units. Each unit must have clear done conditions to reduce risk and improve traceability throughout the engineering workflow.

How should I review AI-generated code to catch edge cases and security issues?

Review AI-generated code by prioritizing invariants, edge cases, and security assumptions. Avoid wasting time on style nits handled by automated tools, focusing structured code review on critical functionality and reliability.

Does eval-first agentic engineering work for solo engineers building AI features?

Eval-first agentic engineering works for solo engineers building AI features by providing a structured workflow. It allows them to run baseline evals, route subtasks to optimal models, and ensure critical code quality checks efficiently.