Guide · Agent skill
How to use the Agentic Engineering agent skill (agentic-engineering)
Updated · written with AI from the project's own documentation and checked against our catalogue data
The agentic-engineering skill is a set of working habits for software projects where an AI coding agent writes most of the code and a human sets the quality and risk rules. It is written as instructions the agent follows, not as a tool that runs by itself. After this guide you will know how to install it, how to ask for it in plain language, and what the agent will do differently once it is loaded.
Agentic Engineering Workflowaffaan-m/ECC · MIT Download the skill Quick start
- 1Download and unzip. Download the ZIP from this page and unzip it to get SKILL.md.
- 2Place the skill folder. Move it to ~/.claude/skills/ for personal use or to your project's .claude/skills/ folder for one project.
- 3Or upload in the Claude apps. In the Claude apps, open Settings, go to Capabilities, and upload the skill under Skills.
- 4Describe your task. Ask for help in plain terms, such as splitting a feature into 15-minute units or writing an eval before implementation.
- 5Write the eval first. Have the agent define the test that captures desired behavior and record the baseline failures before coding.
- 6Review and log. Check the output against the review checklist and record model tier, retries, time and outcome for the task.
What the skill makes the agent do
The skill tells the agent to work in four ways. First, it defines what done means before any coding starts. Second, it breaks large tasks into pieces it calls agent-sized units. Third, it chooses a model tier based on how hard each piece is. Fourth, it measures results with evals and regression checks.
An eval-first loop is the core habit. The agent writes a test that captures the behavior you want, runs it to record the current failures, implements the change, reruns the test, and then checks other tests for regressions.
- Define completion criteria before execution
- Split work into units that take about 15 minutes each
- Route simple work to Haiku, implementation to Sonnet, and architecture or root-cause analysis to Opus
- Track model tier, token estimate, retries, time and outcome per task
Install the skill from the ZIP
Download the ZIP from this page and unzip it. The package contains one file, SKILL.md. Put the unzipped skill folder in one of two places, depending on how you want to use it.
For a personal setup available across your projects, place it in ~/.claude/skills/. For a single project, place it in that project's .claude/skills/ folder so it applies only there.
If you use the Claude apps instead, open Settings, go to Capabilities, and upload the skill under Skills.
- Personal: ~/.claude/skills/
- Single project: your project's .claude/skills/ folder
- Claude apps: Settings → Capabilities → Skills
Trigger the skill with natural requests
You do not need a special command. Describe the kind of work you are doing and the agent can match it to the skill. The skill's description says it applies when AI agents perform most implementation work and humans enforce quality and risk controls.
Phrases that fit its stated uses include asking for help planning how an agent should split a task, choosing which model tier to use, writing tests before implementation, or reviewing AI-generated code for edge cases and security assumptions. Be explicit about the outcome you want, such as a test that fails first and then passes.
- Help me split this feature into 15-minute units an agent can verify on its own.
- Write an eval for this behavior first, run it, then implement the change.
- Review this AI-generated code for edge cases, error handling and security assumptions.
- Which model tier should handle this rename versus this architecture question?
Work through an example task
Suppose you want to add user authentication. The skill suggests splitting it into four units, each with one dominant risk: password hashing (security risk), a login endpoint (API contract risk), session management (state risk), and route protection with middleware (auth logic risk). Each unit should be independently verifiable and have a clear done condition.
A single two-hour unit covering all of those risks is the pattern the skill calls bad decomposition.
Task: Add user authentication
├─ Unit 1: Add password hashing (15 min, security risk)
├─ Unit 2: Create login endpoint (15 min, API contract risk)
├─ Unit 3: Add session management (15 min, state risk)
└─ Unit 4: Protect routes with middleware (15 min, auth logic risk)Choose model tiers and sessions
Start with the lowest tier that fits the task. The skill says to escalate to a higher tier only when a lower tier fails with a clear reasoning gap. For sessions, it suggests continuing one session for closely related units, starting a fresh session after major phase changes, and compacting after a milestone is complete rather than in the middle of debugging.
- Haiku: classification, boilerplate transforms, narrow edits
- Sonnet: implementation and refactors
- Opus: architecture, root-cause analysis, multi-file invariants
- Continue a session for closely coupled units; start fresh after major phase transitions
Review AI-generated code and track cost
When reviewing, the skill focuses on invariants and edge cases, error boundaries, security and auth assumptions, and hidden coupling or rollout risk. It says not to spend review time on style disagreements when automated format and lint tools already enforce style.
For cost tracking, record the model tier, a token estimate, retries, wall-clock time and the outcome for each task. A simple log like the one below makes retries and cost visible across a project.
- Edge cases handled (null, empty, boundary values)
- Error handling comprehensive
- Security assumptions validated
- No hidden coupling between modules
- Rollout risk assessed (breaking changes, migrations)
Task: Implement user login
Model: Sonnet
Tokens: ~5k input, ~2k output
Retries: 1 (initial implementation had auth bug)
Time: 8 minutes
Outcome: SuccessSafety notes: scripts and network
This skill runs no scripts and makes no network calls, and it lists no required packages or tools. It is only instruction text, so installing it does not change your system beyond placing the files.
Because it is instructions, the agent still has whatever access your setup gives it. The skill does not add tools, so any risk comes from the work the agent does with the access you already allow.
- Runs scripts: no
- Uses network: no
- Requires: nothing listed
What people use it for
- Splitting a feature such as user authentication into independently verifiable units
- Writing a failing test first, then implementing and checking for regressions
- Choosing Haiku, Sonnet or Opus for different parts of the same project
- Reviewing AI-generated code for edge cases, error handling and security assumptions
- Tracking retries and token estimates across a team's agent tasks
Frequently asked questions
How do I install the agentic-engineering skill?
Download the ZIP from this page and unzip it to get SKILL.md. Place the folder in ~/.claude/skills/ for personal use, or in your project's .claude/skills/ folder for one project. In the Claude apps, you can instead upload it under Settings → Capabilities → Skills.
Does the agentic-engineering skill require anything else to run?
The skill lists no requirements. It runs no scripts and uses no network. It is a set of written instructions for the agent, so it adds no new tools by itself.
Is the agentic-engineering skill free to use?
The skill is published under the MIT licence, as listed on this page. Check the licence file in the source repository for the full terms.
Can a beginner use this skill to build an app?
The skill is not meant for that. It assumes engineering experience and a human who enforces quality, and it does not teach coding. It also depends on tests or automated checks existing in the project.
What is the eval-first loop?
It is a workflow where the agent writes a test that captures the desired behavior, runs it to record baseline failures, implements the change, reruns the test, and checks other tests for regressions. The skill says this loop depends on having tests or automated checks.
How does this compare to the tdd-workflow or verification-loop skills?
The source says this skill can be combined with tdd-workflow for test-driven development and with verification-loop for continuous validation during implementation. It also suggests search-first before implementation and coding-standards during review.
New agent skills, repos and AI tools — every week
The best new skills and open-source projects, the fastest-growing repos, and one free prompt. Five minutes to read. Unsubscribe anytime.
Our verdict
Use this skill if you already have an AI agent doing most of your implementation and you want its work broken into testable pieces, with cost and retries tracked. Pick something else if you want a finished app without reviewing code, if your project has no tests or automated checks, or if you are learning to code, since the skill assumes engineering experience.
Download the skill