Skip to content
Skillpedia
Agents280k · #8

agentic-engineering

Makes your agent work smarter and more cost-effectively. It plans tasks, breaks them into smaller parts, and chooses the best AI tool for each step.

What it does

This tool helps plan and execute engineering work using artificial intelligence. It breaks down large tasks into smaller parts, checks for quality, and selects the right AI model for each part.

When to use it

  • ✓When planning a software project to be built by AI.
  • ✓When you need to ensure AI's work meets quality standards.
  • ✓When managing projects where AI does most of the implementation.

Example of what to ask your AI

“Plan the creation of a simple website, breaking the work into steps an AI can handle, and tell me how to check if each step was successful.”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/affaan-m/ECC/blob/main/pi/core/skills/agentic-engineering/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/affaan-m/ECC/blob/main/pi/core/skills/agentic-engineering/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

The tool first defines what success looks like, then breaks down the work into small, manageable pieces. For each piece, it chooses the most suitable AI model and verifies the results.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add affaan-m/ECC --skill agentic-engineering

Or download just the file:

curl -L https://raw.githubusercontent.com/affaan-m/ECC/main/pi/core/skills/agentic-engineering/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Agentic Engineering

Use this skill for engineering workflows where AI agents perform most implementation work and humans enforce quality and risk controls.

Operating Principles

  1. Define completion criteria before execution.
  2. Decompose work into agent-sized units.
  3. Route model tiers by task complexity.
  4. Measure with evals and regression checks.

Eval-First Loop

  1. Define capability eval and regression eval.
  2. Run baseline and capture failure signatures.
  3. Execute implementation.
  4. 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.

FAQ

What is 'agentic engineering'?

It's a way of using AI to perform engineering tasks, where the AI does most of the work and humans oversee quality control.

What is the '15-minute unit rule'?

It means each small task created for the AI should take about 15 minutes to complete and be easy to verify.

How does the tool choose which AI model to use?

It uses simpler models for easy tasks (like classifying information) and more powerful models for complex tasks (like deep analysis or architecture).

Details

Original description by the author

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. Use when planning or executing engineering work that agents will carry out end to end.

repo: affaan-m/ECC

Popularity

GitHub stars
280k
Ranking position
#8
License
MIT
Updated
10/15/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills