Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing.
git clone https://github.com/affaan-m/ECC.git--- name: agentic-engineering description: Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing. metadata: origin: ECC --- # 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.
[{"step":"Define the problem and success criteria","action":"Clearly state the task, constraints (e.g., cost, time), and measurable outcomes. Use [PLACEHOLDERS] to standardize inputs.","tip":"Include specific metrics (e.g., 'reduce latency to <500ms') to guide the agent's evaluation."},{"step":"Decompose the task","action":"Break the problem into 3-5 sub-tasks with clear success criteria for each. Prioritize tasks that are prerequisites for others.","tip":"Use tools like Mermaid diagrams or bullet points to visualize dependencies between sub-tasks."},{"step":"Select models/tools for each sub-task","action":"Use cost-aware routing to pick the best model/tool for each step. For example, use smaller models for initial exploration and larger ones for complex validation.","tip":"Track model costs in a spreadsheet or tool like LangSmith to optimize spending over time."},{"step":"Execute and evaluate iteratively","action":"Run each sub-task, evaluate against criteria, and adjust if needed. Document failures and refinements in a log.","tip":"Use eval frameworks (e.g., pytest, custom scripts) to automate validation where possible."},{"step":"Iterate and optimize","action":"After completing all sub-tasks, review the full solution for further optimizations (e.g., combining steps, reducing model calls).","tip":"Use the agent to simulate edge cases or stress tests to uncover hidden bottlenecks."}]
No install command available. Check the GitHub repository for manual installation instructions.
git clone https://github.com/affaan-m/ECC/tree/main/skills/agentic-engineeringCopy the install command above and run it in your terminal.
Launch Claude Code, Cursor, or your preferred AI coding agent.
Use the prompt template or examples below to test the skill.
Adapt the skill to your specific use case and workflow.
Act as an agentic engineer to solve [TASK]. Follow this process: 1) Decompose the problem into [N] sub-tasks. 2) For each sub-task, generate a plan with success criteria. 3) Execute the first sub-task using [TOOL/MODEL] with [PARAMETERS]. 4) Evaluate the output against the criteria. 5) If successful, proceed to the next sub-task; if not, refine or retry. Use cost-aware model routing to select the most efficient model for each step. Start with: [INITIAL_INPUT].
I've been tasked with optimizing a Python script that processes 10,000 CSV files daily, each containing 500K rows. The script currently takes 4 hours to run on a t3.large EC2 instance, costing $0.08/hour. My goal is to reduce runtime to under 2 hours while keeping costs under $0.10 per run. **Decomposition:** 1. Profile the current script to identify bottlenecks. 2. Optimize the slowest operation (likely the CSV parsing loop). 3. Implement parallel processing with multiprocessing. 4. Validate the optimized version with a 10% sample. 5. Benchmark against the original. **Execution Plan:** For sub-task 1, I'll use cProfile on the original script with a 1GB sample file. Success criteria: identify the top 3 time-consuming functions. **Model Selection:** Using cost-aware routing, I'll use Llama3:8b for initial profiling (low cost) and switch to gpt-4o for complex optimization steps (higher accuracy needed). **Output:** After running cProfile, the top bottlenecks are: - `parse_csv()`: 1200s (60% of runtime) - `transform_data()`: 400s (20%) - `write_output()`: 200s (10%) Next, I'll optimize `parse_csv()` by replacing the naive loop with pandas' `read_csv(chunksize=10000)`. I'll execute this using the same EC2 instance but with 4 CPU cores allocated. The estimated cost for this step is $0.02. After implementation, the sample run completes in 15 minutes (vs. original 2.5 hours). The new `parse_csv()` now takes 400s (vs. 1200s), meeting the success criteria. I'll proceed to parallelize `transform_data()` next.
skills-collection
Take a free 3-minute scan and get personalized AI skill recommendations.
Take free scan