Eval-First Agentic Engineering for Cost-Aware Workflows

Where this fits

You're shipping a feature and want Claude to write most of the code, but you can't afford silent regressions or runaway token spend. This skill is for developers who need a disciplined workflow: define done first, break work into small verifiable units, route each unit to the right model, and validate with evals before and after.

Why agents benefit

• Completion criteria are defined before code is written, so the agent can self-check without asking for clarifications.
• The 15-minute-unit rule keeps each task small enough to verify independently, reducing the blast radius of a bad edit.
• Cost-aware routing means simple edits go to Haiku, implementations to Sonnet, and architecture decisions to Opus — so budget is spent where it matters.
• Eval-first regression checks give the agent a signal for "did my change break something?" beyond unit tests.
• Session strategy for closely related units keeps context warm, avoiding repeated re-uploads and lost state between steps.

Practical scenarios

Refactoring a legacy module safely

You have a payment module with subtle invariants. The skill's eval-first loop captures current behavior with focused regression evals, then the agent decomposes the refactor into 15-minute units. Each unit is verified against the eval suite before moving on, so you can approve changes with confidence.

Generating boilerplate across many services

You need consistent API clients across five services. Model routing sends the repetitive transform work to Haiku while Sonnet reviews the generated output for consistency. The done condition is clear: every service has a passing smoke eval and no manual edits are needed.

Building a feature with acceptance evals

Before implementation, you and the agent define a capability eval that encodes the user-visible behavior. The agent implements against that eval, reruns it after each unit, and only then does it hand off to you for human judgment. This turns "I think it works" into measurable proof.

Add it to your agent workflow

Install the skill with:

npx skills add loulanyue/awesome-claude-notes --skill agentic-engineering

Then invoke it with a concrete goal:

Use the agentic-engineering skill for this task.
Goal: Add rate limiting to the gateway.
Done: Eval for 429 responses passes; no change to existing route evals.

The agent will decompose the work, route subtasks by model tier, and run the evals you define before returning.

Compare before adopting

Before making it a permanent part of your stack, compare it against your own quality signals: does the eval-first loop catch regressions in your codebase? Check maintenance freshness — is the skill actively updated? Consider alternatives like your own prompting templates or other agent skills. Finally, assess workflow fit: the 15-minute-unit rule works best for implementation-heavy tasks, not for open-ended research.

Why it is worth tracking

The project has 270 stars and an origin in practical ECC workflows, which signals community validation beyond a single author. It is worth evaluating when you are formalizing agent workflows and need a structured alternative to ad-hoc prompting. Track it, run it on a small refactor, and see whether the eval-first discipline reduces your review load. For a more detailed breakdown, see https://www.openagentskill.com/skills/loulanyue-agentic-engineering.