agentic-engineering
by affaan-mLearn the agentic-engineering skill for eval-first execution, task decomposition, model routing, and safer workflow automation with regression checks.
This skill scores 68/100, which means it is worth listing for users who want an agentic engineering workflow, but it is not yet a highly guided install. The repository gives enough substance to help an agent act with less guesswork than a generic prompt, especially around eval-first execution and model routing, but directory users should expect a fairly high-level playbook rather than a tightly operational tool.
- Clear use case and trigger: the description and opening guidance explicitly target engineering workflows where AI agents do most implementation work.
- Practical operating model: it lays out eval-first execution, decomposition into 15-minute units, and model routing by task complexity.
- Good decision support for agents: it emphasizes completion criteria, regression checks, session strategy, and review priorities like invariants and security assumptions.
- No install command, scripts, or support files, so adoption depends entirely on reading the markdown guidance.
- Workflow remains fairly abstract: there are no examples, checklists, or repo-linked references to reduce ambiguity for first-time use.
Overview of agentic-engineering skill
agentic-engineering is a workflow skill for teams that want AI to do most of the implementation work without losing control of quality, scope, or cost. The agentic-engineering skill is best for engineers who already know how they want to ship, but need a repeatable system for decomposition, evals, and model selection instead of a generic one-shot prompt.
What users usually want from agentic-engineering is not inspiration; it is a practical operating model for AI-assisted delivery. The core job-to-be-done is to turn a vague engineering task into small verifiable units, choose the right model tier for each unit, and validate results with regression checks before moving on.
Why this skill is different
Unlike prompt-only approaches, agentic-engineering bakes in execution discipline: define completion criteria first, break work into agent-sized pieces, and verify against evals. That makes it a stronger fit for multi-step coding work, refactors, and workflow automation than for casual code drafting.
Best fit for this skill
Use agentic-engineering if you care about:
- reducing rework on agent-written code
- keeping AI tasks small enough to review
- routing simple tasks to cheaper models and hard tasks to stronger ones
- catching regressions early instead of after merge
Where it is a poor fit
It is less useful when the task is tiny, purely stylistic, or already fully constrained by tests and lint. If you just need a short code snippet or a single-line fix, the agentic-engineering guide may be more process than you need.
How to Use agentic-engineering skill
Install and open the source
For agentic-engineering install, add the skill and then read the skill file directly:
npx skills add affaan-m/everything-claude-code --skill agentic-engineering
Start with skills/agentic-engineering/SKILL.md. Because this repo does not include extra rule folders or helper scripts, the main value is in the skill body itself, not in a large support tree.
Turn a rough task into a good prompt
The skill works best when your input already states:
- the goal
- the expected done condition
- the main risk
- the surfaces that may break
A weak request is: “Improve the auth flow.”
A stronger request is: “Refactor the auth flow so login success, token refresh, and expired-session handling are separately testable. Keep the public API stable, add regression checks for token refresh failure, and optimize for low-risk incremental changes.”
That second version gives agentic-engineering the material it needs for decomposition and eval-first execution.
Follow the workflow in the skill
In practice, the agentic-engineering usage pattern is:
- define completion criteria
- split the task into 15-minute units
- pick model tiers by complexity
- run baseline checks before changing code
- validate each unit with focused tests or evals
- re-check regressions before combining work
This is especially useful for agentic-engineering for Workflow Automation, where the work often spans multiple files, fragile edge cases, and changes that look correct until a downstream check fails.
What to read first
Read in this order:
SKILL.mdfor the operating model- the sections on Operating Principles and Eval-First Loop
- Task Decomposition for the 15-minute unit rule
- Model Routing and Review Focus for AI-Generated Code
- Cost Discipline if you are managing token or model spend
agentic-engineering skill FAQ
Is agentic-engineering only for large projects?
No. It is most valuable on work that has hidden coupling, but it can also help on medium tasks if the risk of regressions is high. If the change can be verified in one quick edit, the overhead may not be worth it.
How is this different from a normal prompt?
A normal prompt asks the model to produce code. The agentic-engineering skill asks the model to work in a controlled loop: define success, decompose, route the right model, and verify with evals. That usually produces better outcomes when the implementation path is uncertain.
Is agentic-engineering beginner friendly?
Yes, if the user can describe a task and recognize a good done condition. It is not a beginner tutorial for coding itself; it is a process skill for making AI coding safer and more predictable.
When should I not use it?
Skip it when your task is trivial, when speed matters more than rigor, or when there is no meaningful way to measure success. It is also a weaker choice if you want pure exploration rather than controlled engineering output.
How to Improve agentic-engineering skill
Give it sharper inputs
The biggest quality gain comes from better task framing. Include acceptance criteria, constraints, and known failure modes up front. For example, mention whether backward compatibility matters, whether tests already exist, and which edge cases are most likely to break.
Use evals that match the real risk
The skill is strongest when your checks reflect actual user impact, not just syntax. If the risk is auth, test refresh and failure paths. If the risk is automation, test retries, idempotency, and state transitions. That is the heart of agentic-engineering improvement.
Iterate after the first pass
Do not treat the first output as final. Ask for a narrower decomposition, a different model routing plan, or a stricter regression gate if the result feels too broad. Good agentic-engineering workflow usually comes from tightening the loop, not from expanding the prompt.