ecc-tools-cost-audit
by affaan-mecc-tools-cost-audit is an evidence-first audit skill for ECC Tools cost spikes, runaway PR creation, quota bypass, premium-model leakage, and duplicate jobs. Use it for Backend Development investigations that trace a request from webhook to worker to billing decision and prove where spend is being created.
This skill scores 78/100, which is solid enough for directory listing. It gives users a clear, evidence-based workflow for investigating ECC Tools cost and billing issues, so agents can trigger it more reliably than with a generic prompt. The main limitation is that it reads more like an operator guide than a fully packaged skill, so users should expect some repo-context knowledge and may need to interpret a few steps themselves.
- Clear trigger conditions for cost spikes, PR recursion, quota bypass, and premium-model leakage
- Strong operational framing with a focused sibling-repo scope and linked supporting skills for related investigations
- Substantial body content with headings and constraints, indicating a real workflow rather than a placeholder
- No install command or companion support files, so adoption may require manual setup or extra context
- Workflow is scoped to the sibling ECC-Tools repo, limiting reuse outside that codebase
Overview of ecc-tools-cost-audit skill
What ecc-tools-cost-audit is for
ecc-tools-cost-audit is an evidence-first audit skill for the ECC Tools GitHub App when cost is rising for the wrong reasons: runaway PR creation, usage-limit bypasses, duplicate jobs, or premium-model leakage. It is best for Backend Development work where you need to trace a request from webhook to worker to billing decision and prove where spend is being created.
Who should use it
Use the ecc-tools-cost-audit skill if you are debugging behavior in the sibling ECC-Tools repo and need a focused cost or billing investigation, not a broad code review. It is a good fit when you already suspect a specific failure mode and want a workflow that forces you to verify the path, the gate, and the customer impact.
What makes it different
The skill is designed around bounded auditing: find the exact code path, isolate the cost trigger, and separate app behavior from billing math. That makes it more useful than a generic prompt for incidents involving webhooks, queue retries, entitlements, or PR automation loops.
How to Use ecc-tools-cost-audit skill
Install and open the right files first
Use the ecc-tools-cost-audit install path from your directory toolchain, then start with SKILL.md. For this repo, there are no helper scripts or reference folders, so the highest-value read order is SKILL.md first, then the sibling ECC-Tools code paths that handle webhooks, queue workers, PR creation, usage reservation, and paid-gate checks.
Turn a vague issue into a useful prompt
The ecc-tools-cost-audit usage works best when you name the symptom, scope, and proof goal. Strong inputs look like: “Audit why free-tier users are reaching premium analysis in the webhook worker, identify the gating bug, and show the minimal fix plus verification steps.” Weak inputs like “find the billing issue” leave too much routing ambiguity.
Follow the skill stack intentionally
The ecc-tools-cost-audit guide expects you to borrow adjacent ECC-native skills when the problem crosses layers. Use search-first before inventing helpers, agentic-engineering when tracing flow across modules, customer-billing-ops when dollar impact must be quantified cleanly, and verification-loop when you need rerun-safe proof after a fix.
Practical workflow for Backend Development
Start by mapping the request path, then check where usage is reserved, where retries can duplicate work, and where model selection or PR creation is decided. If the first pass does not show the leak, compare the “happy path” and the “retry path” separately; cost bugs here often hide in exception handling, queue re-entry, or conditions that only fail for free users.
ecc-tools-cost-audit skill FAQ
Is ecc-tools-cost-audit only for billing issues?
No. It is for any backend behavior in ECC Tools that produces avoidable spend, including repeated jobs, duplicated PRs, and entitlement bypasses. Billing math matters, but the main job is finding the code path that causes the cost.
Do I need the whole repository to use it well?
No, but you do need the relevant execution path. The skill is most effective when you can inspect webhook handlers, workers, and billing or gating logic together instead of reading files in isolation.
When should I not use this skill?
Do not use it for a broad architecture review, frontend bug, or a generic “make the app cheaper” request. If the issue is not tied to ECC Tools cost behavior, a more general debugging or refactoring skill will be a better match.
Is it beginner-friendly?
Yes, if you can describe a concrete symptom. The skill guides the investigation, but it still works best when you provide an example event, suspected trigger, or observed cost spike rather than a fully open-ended request.
How to Improve ecc-tools-cost-audit skill
Give the audit a measurable target
The ecc-tools-cost-audit skill produces better results when you specify what “bad” looks like: extra PRs per webhook, unexpected premium-model calls, failed limit checks, or duplicate processing after retries. Numbers, timestamps, and example event IDs reduce guesswork and make the first pass sharper.
Provide the narrowest path you can
Name the exact backend surface involved: webhook receiver, queue consumer, reservation logic, PR creation flow, or entitlement gate. If you know the route is “free user + retry + premium model selection,” include all three; that combination is usually more valuable than a general complaint.
Ask for proof, not just a patch
The best ecc-tools-cost-audit usage asks for a traced root cause, the minimal code change, and the verification plan. That keeps the answer grounded in observable behavior and helps you confirm the fix did not shift cost elsewhere.
Iterate on failure modes after the first pass
If the first result is too broad, refine it around the likely failure mode: duplicate queue execution, missing idempotency, misrouted model choice, or a bypassed reservation check. Each iteration should remove ambiguity, because this skill is strongest when the audit boundary is tight and the expected outcome is explicit.