AGENT SKILL

budgets-auditor

Audits AWS Budgets for cost-overrun blind spots: accounts with zero budgets, budgets configured without notifications (decorative budgets), single- threshold alerts that leave no time to react, ACTUAL-only alerts with no FORECASTED warning, SNS topic policies that silently block delivery (missing budgets.amazonaws.com publish principal), breached or on-track-to- breach actual-vs-forecast spend, and missing zero-spend guardrails for new or sandbox accounts. Emits a deterministic verdict (NO_BUDGET | NO_ALERT | CONFIG_GAP | OK) per account with enumerated findings and specific CLI remediation. Use when reviewing cost budgets, checking budget alert thresholds, validating SNS notification wiring, auditing spend posture, or hardening cost controls before a billing review.

License 许可
Apache-2.0
最近更新
2026-09-24
Stars
★ 4
Forks
0

01 前言 Front Matter

name
budgets-auditor
license
Apache-2.0
metadata
{ "tags": "budgets, finops, cost-control, alerting, sns, spend, audit", "phase": "2", "author": "Jacky Chan — AWS Community Builder", "domain": "aws-cloudops", "family": "FinOps", "version": "0.1.0", "keywords": "AWS Budgets, cost budget, budget alert, notification threshold, FORECASTED, ACTUAL, SNS topic policy, budgets.amazonaws.com, zero-spend budget, cost overrun, FinOps, billing alarm, cost control, spend posture, budget action, RI coverage, Consolidated Billing, budget audit, threshold gap", "complexity": "medium", "entry_point": "false", "when_to_use": "Reviewing cost budgets before a billing review or production cutover, checking that budget alerts are wired to a real SNS topic, validating threshold coverage (early-warning vs over-budget), auditing actual-vs- forecast breach posture, or hardening spend controls for a new or sandbox account.", "requires_llm": "true", "verdict_shape": "NO_BUDGET | NO_ALERT | CONFIG_GAP | OK", "invocation_schema": "Input: either (a) an account budget inventory (list of budgets, each with notifications, subscribers, SNS topic policies, and calculated spend), OR (b) an account-id for live-account audit. Output: deterministic BUDGET/VERDICT/REASON/FINDINGS/REMEDIATION block per budget plus an account-level aggregate verdict, where VERDICT is one of NO_BUDGET, NO_ALERT, CONFIG_GAP, OK.", "supports_pipeline": "true", "activation_triggers": "audit my AWS budgets, check budget alerts, is my budget wired to SNS, budget notification threshold, zero-spend budget, cost overrun alert, budget forecast exceeded, spend posture audit, budget SNS policy, decorative budget" }
description
Audits AWS Budgets for cost-overrun blind spots: accounts with zero budgets, budgets configured without notifications (decorative budgets), single- threshold alerts that leave no time to react, ACTUAL-only alerts with no FORECASTED warning, SNS topic policies that silently block delivery (missing budgets.amazonaws.com publish principal), breached or on-track-to- breach actual-vs-forecast spend, and missing zero-spend guardrails for new or sandbox accounts. Emits a deterministic verdict (NO_BUDGET | NO_ALERT | CONFIG_GAP | OK) per account with enumerated findings and specific CLI remediation. Use when reviewing cost budgets, checking budget alert thresholds, validating SNS notification wiring, auditing spend posture, or hardening cost controls before a billing review.
compatibility
Agent runtime that reads SKILL.md (Claude Code, Cursor, Windsurf, Codex, Gemini). No AWS CLI required for offline budget-document classification. Live-account audits use aws budgets describe-budget, aws budgets describe-budgets, aws budgets describe-notifications-for-budget, aws budgets describe-subscribers-for-notification, and aws sns get-topic-attributes (AWS CLI v2, SSO or key-based credentials).

02 资源文件 19

03 SKILL.md 正文

Budgets Auditor

Mindset

One-line takeaway: a budget without a working notification is decorative — it tracks spend nobody watches. The verdict escalates through four blind-spot tiers, and three AWS Budgets behaviours are easy to misjudge: cost-data lag (actuals trail real spend by hours), silent SNS delivery failure (a missing topic-policy statement produces zero console error), and ACTUAL-vs-FORECASTED semantics (an ACTUAL alert at 100% fires after the money is spent).

AWS Budgets is the first line of cost control, but the configuration is where alerting silently fails. Three failure modes dominate:

  • No budgets at all — the account has zero budgets. Spend runs completely unbounded with no visibility. This is the default state for new accounts and the most dangerous posture for a compromised credential or a runaway resource.
  • Decorative budget — a budget exists but has zero notifications (or notifications with no subscribers). It tracks spend in the console but never alerts anyone. The operator believes they have cost control; they have a dashboard.
  • Wired-wrong alert — notifications exist but the SNS topic policy omits the budgets.amazonaws.com publish principal, OR there is a single 100% ACTUAL threshold with no early warning and no forecast. The alert either silently never delivers, or arrives too late to act on.

Quick reference — verdict thresholds

Condition Verdict Step
Account has zero budgets NO_BUDGET 1
Budget has zero notifications, or all notifications have zero subscribers NO_ALERT 2
SNS subscriber present but topic policy lacks budgets.amazonaws.com publish CONFIG_GAP 3
Only one threshold, or no threshold below 80% CONFIG_GAP 4
COST budget with ACTUAL notifications but zero FORECASTED notifications CONFIG_GAP 5
ForecastedSpend > BudgetLimit with no FORECASTED notification at the breached ratio CONFIG_GAP 6
ActualSpend > BudgetLimit (breached) with no ACTUAL notification fired CONFIG_GAP 6
New/sandbox account (flagged) with no zero-spend or low-spend budget CONFIG_GAP 7
All budgets: multi-threshold, ACTUAL+FORECASTED, SNS wired, not breached OK 8

Steps apply in order — the first step that triggers sets the per-budget verdict. The account-level verdict is the worst per-budget verdict, where NO_BUDGET > NO_ALERT > CONFIG_GAP > OK. See the ordered classification below for edge cases and additive findings.

Pre-flight: input and account-metadata gate

Before classification, validate the input structure and identify metadata that short-circuits the audit.

Live-account sweep note (pagination): moved verbatim to references/diagnostic-commands.md. Load on demand before running a live-account budgets sweep.

Live-account pre-flight checks (skip if doing offline budget-doc audit): Full pre-flight command list moved verbatim to references/diagnostic-commands.md. Load on demand when auditing a live account (permissions, payer inventory, budget performance history).

If the budget inventory is malformed (invalid JSON/YAML, missing required BudgetName or BudgetLimit on a COST budget), output:

BUDGET: <name or unknown>
VERDICT: ERROR
REASON: Budget configuration is not valid — cannot classify (missing BudgetName or BudgetLimit).
REMEDIATION: Re-fetch with `aws budgets describe-budget --account-id <id> --budget-name <name> --region us-east-1` and re-audit.

Do not attempt classification on malformed input.

Process — Classification logic (apply in order, aggregate worst)

Step 0: Expert knowledge — non-obvious AWS Budgets behaviours

All Step 0 behaviours moved verbatim to references/advanced-patterns.md. Load on demand when a verdict depends on a non-obvious Budgets behaviour (cost-data lag, silent SNS failure, RI/SP types, auto-adjust, CostTypes).

Step 1: Budget existence gate (NO_BUDGET — highest priority)

If the account has zero budgets of any type (COST, RI_, SP_, USAGE), the verdict is NO_BUDGET. This is the worst posture: no spend visibility, no alerting, no forecast. This is the default state for newly created accounts and the highest-risk configuration for credential compromise or runaway resources.

NO_BUDGET short-circuits all other steps — there is nothing to evaluate notifications against. The remediation is to create at minimum a total-account cost budget and (for new/sandbox accounts) a zero-spend guardrail.

Step 2: Notification and subscriber gate (NO_ALERT)

For each budget, evaluate notification coverage:

  • Zero notifications on the budget → the budget is decorative. It tracks spend in the console but never alerts anyone. Per-budget verdict: NO_ALERT.
  • Notifications exist but every notification has an empty subscriber list (Subscribers: []) → the notification has nowhere to deliver. Per-budget verdict: NO_ALERT.

A budget that triggers NO_ALERT is functionally equivalent to no budget for the purpose of alerting — the spend may as well be unmonitored. The difference between NO_BUDGET and NO_ALERT is that NO_ALERT means "the tracking exists but the human-in-the-loop is severed," while NO_BUDGET means "there is no tracking at all." Both are HIGH risk.

Step 3: SNS topic policy delivery check (CONFIG_GAP)

For each notification with an SNS subscriber (SubscriptionType: SNS), the notification can only deliver if the SNS topic policy grants sns:Publish to the budgets.amazonaws.com service principal. Retrieve the topic policy (aws sns get-topic-attributes --topic-arn <arn>) and check for a statement matching:

{
  "Effect": "Allow",
  "Principal": { "Service": "budgets.amazonaws.com" },
  "Action": "SNS:Publish",
  "Resource": "<topic-arn>"
}
  • Statement absent → the notification will silently fail to deliver. Per-budget verdict: CONFIG_GAP (Finding: SNS_POLICY_GAP). This is the most common reason budget alerts "don't work" and produces zero console error.
  • Statement present but scoped to a different region or account → CONFIG_GAP (the ARN mismatch causes rejection).
  • EMAIL/EMAIL-JSON subscribers do NOT require an SNS topic policy — Budgets delivers directly to the email address. Skip Step 3 for email-only subscribers. (Note: email subscribers still require a confirmation click on the AWS-sent subscription email; an unconfirmed email is a delivery gap but is surfaced in the console, unlike the silent SNS policy failure.)

Step 4: Threshold coverage check (CONFIG_GAP)

For each COST budget with notifications, evaluate the threshold set:

  • Single threshold (only one notification on the budget) → CONFIG_GAP (Finding: SINGLE_THRESHOLD). A single alert leaves no time to react — regardless of where it sits, there is no early-warning tier.
  • No threshold below 80% → CONFIG_GAP (Finding: NO_EARLY_WARNING). If the lowest threshold is at 80% or higher, the operator gets no awareness signal before the budget is nearly exhausted. Best practice: at least one threshold at 50% (awareness) and one at 80-90% (action).
  • No threshold at or above 100% → CONFIG_GAP (Finding: NO_BREACH_ALERT). If no notification covers the actual breach point, the operator may never learn they are over budget.

A budget with thresholds at {50%, 80%, 100%} or {70%, 90%, 100%} passes this step. A budget with only {100%} or only {90%} fails.

Step 5: FORECASTED coverage check (COST budgets only — CONFIG_GAP)

For each COST budget (BudgetType COST or USAGE), evaluate notification types:

  • All notifications are ACTUAL, zero FORECASTED → CONFIG_GAP (Finding: NO_FORECAST). Without a FORECASTED notification, the operator has no predictive signal. Combined with cost-data lag, an ACTUAL-only alert at 100% arrives after the budget is already breached by hours. A FORECASTED notification at 80-100% projects month-end spend and gives lead time.

This check does NOT apply to RI/SP budgets (their "forecast" is utilization trajectory, handled differently) or to DAILY budgets where month-end projection is meaningless.

Step 6: Actual-vs-forecast breach check (CONFIG_GAP)

For each COST budget, compare CalculatedSpend against BudgetLimit:

  • ForecastedSpend >= BudgetLimit and NO FORECASTED notification covers the breached ratio → CONFIG_GAP (Finding: FORECAST_BREACH_UNALERTED). The budget is on track to exceed by month-end but no forecast alert will fire.
  • ActualSpend >= BudgetLimit (already breached) and NO ACTUAL notification covers 100% → CONFIG_GAP (Finding: ACTUAL_BREACH_UNALERTED). The budget has been exceeded but no actual alert will fire.

Note: a breach with a matching alert that WILL fire is informational, not a CONFIG_GAP — the system is working as designed. Only flag when the breach is uncovered by the notification set.

Step 7: Zero-spend guardrail for new/sandbox accounts (CONFIG_GAP)

If the account is flagged as new, sandbox, or non-production (operator-provided context, or account name/tag convention), check for a zero-spend or low-spend guardrail:

  • No COST budget with BudgetLimit <= $1.00 (or <= $0.01) and a 100% ACTUAL notification → CONFIG_GAP (Finding: NO_ZERO_SPEND_GUARDRAIL). A zero-spend budget catches ANY unauthorized spend immediately — the leading signal for a compromised credential, a misconfigured free-tier resource, or a stray workload. Without it, a new account can accumulate charges for days before a normal budget trips.

This check is advisory-in-practice but Config_GAP-in-verdict because the absence of a zero-spend guardrail on a new account is the single highest-leverage FinOps control. For established production accounts, skip this step.

Step 8: Aggregation — worst per-budget verdict wins

The account-level verdict is the maximum severity across all per-budget verdicts, where NO_BUDGET > NO_ALERT > CONFIG_GAP > OK:

account_verdict = max(all_budget_verdicts)

If the account has budgets and all pass Steps 2-7 with no findings, the account verdict is OK. NO_BUDGET is only reachable when the account has zero budgets (Step 1).

Severity/risk mapping (emitted per finding):

  • NO_BUDGET → HIGH (total spend blind spot; default for new accounts)
  • NO_ALERT → HIGH (budget is decorative; spend tracked but never alerted)
  • CONFIG_GAP (SNS_POLICY_GAP) → HIGH (alerts silently fail to deliver)
  • CONFIG_GAP (SINGLE_THRESHOLD / NO_EARLY_WARNING / NO_FORECAST) → MEDIUM
  • CONFIG_GAP (NO_ZERO_SPEND_GUARDRAIL) → MEDIUM for new accounts
  • CONFIG_GAP (breach uncovered) → MEDIUM (the breach is real but alertable with a fix)
  • OK → LOW

Output format (per account)

ACCOUNT: <account-id>
VERDICT: NO_BUDGET | NO_ALERT | CONFIG_GAP | OK
REASON: <1-2 sentences citing the triggering step and worst finding>
FINDINGS:
  - [HIGH] <budget name>: <finding description (Step N)>
  - [MEDIUM] <budget name>: <finding description (Step N)>
  - [OK] <budget name>: <dimension that passed>
REMEDIATION: <specific action per finding, or "None required" if OK>

Worked example — decorative budget with SNS policy gap

ACCOUNT: 111111111111
VERDICT: CONFIG_GAP
REASON: Budget "monthly-total" has a single 100% ACTUAL notification wired to
an SNS topic whose policy omits the budgets.amazonaws.com publish principal —
alerts silently fail to deliver (Step 3), and there is no FORECASTED
notification for lead time (Step 5).
FINDINGS:
  - [HIGH] monthly-total: SNS topic arn:aws:sns:us-east-1:111111111111:budget-alerts
    policy lacks budgets.amazonaws.com sns:Publish — alerts dispatched but
    rejected at delivery (Step 3)
  - [MEDIUM] monthly-total: single threshold at 100% ACTUAL — no early warning
    and no FORECASTED notification (Steps 4, 5)
  - [OK] monthly-total: budget exists with BudgetLimit $10000, not breached
REMEDIATION:
  1. Add the budgets service principal to the SNS topic policy (see Step 3
     remediation CLI).
  2. Add a FORECASTED notification at 80% and an early-warning ACTUAL at 50%.

Edge-case handling

Full edge-case catalog moved verbatim to references/advanced-patterns.md. Load on demand when input hits an edge case (malformed budget, email-only subscriber, payer-covered member, DAILY budget, Budget Action).

Anti-Patterns — NEVER

  • NEVER classify an account with zero budgets as anything other than NO_BUDGET. "No budgets" is a total spend blind spot — the highest-risk FinOps posture. Do not soften it to CONFIG_GAP.

  • NEVER treat a budget with zero notifications as OK. A budget without notifications is decorative — it tracks spend nobody watches. This is NO_ALERT, not OK. The console showing a spend number is not alerting.

  • NEVER assume an SNS subscriber means alerts will deliver. The SNS topic policy MUST explicitly grant sns:Publish to budgets.amazonaws.com. A missing policy statement fails silently with zero console error — this is the #1 reason budget alerts "don't work." Always read the topic policy.

  • NEVER flag an RI_COVERAGE / RI_UTILIZATION / SP_COVERAGE / SP_UTILIZATION budget as cost-breached. These budget types measure reservation effectiveness (a percentage), not spend. They have no dollar BudgetLimit. Applying cost-breach logic to them is a false positive.

  • NEVER treat the absence of a Budget Action as a CONFIG_GAP. Budget Actions (enforcement) are an opt-in tier separate from alerting. Most accounts use alert-only budgets by design. Only flag a misconfigured Action if one is present.

  • NEVER assume "actual under limit" means the budget is safe. Cost-data lag trails real spend by 8-14 hours. A budget at 90% actual may already be over. Always check the FORECASTED spend against the limit, not just actual.

  • NEVER recommend a single-threshold budget as adequate. A lone 100% ACTUAL alert fires after the spend is incurred plus the data lag. A budget needs at least an early-warning tier (50%) and an action tier (80-90%) below the breach alert (100%).

  • NEVER treat a CloudWatch billing alarm as a substitute for a budget. Billing alarms (AWS/Billing EstimatedCharges) are account-total only, update every ~6 hours, and have no FORECASTED projection or filtering. They are legacy defense-in-depth, not a replacement for AWS Budgets.

  • NEVER skip pagination on describe-budgets or describe-notifications-for-budget. The long tail of budgets (beyond page one) is where stale, decorative, and breached budgets hide. Always drain NextToken to completion.

  • NEVER conflate FORECASTED and ACTUAL notification types. FORECASTED projects month-end spend; ACTUAL reports current calculated spend. They are not interchangeable. A budget with only ACTUAL notifications is reactive; a budget with FORECASTED notifications is predictive. Both belong in a mature budget config.

  • NEVER assume a payer-wide budget covers a member account's alerting needs. A payer budget with no LinkedAccount filter aggregates all member spend but a runaway member account can hide inside an aggregate that is under limit. For chargeback and isolation, member accounts need their own budgets or the payer budget must be filtered per account.

  • NEVER propose more than 11 notifications on a single budget. The quota is 11 notifications per budget (hard limit). A remediation proposing a 12th notification will fail with LimitExceededException. Count existing notifications before adding.

  • NEVER ignore the CostTypes filter when assessing breach. A budget with IncludeTax: false under-reports by the tax line. Two budgets with the same limit and different CostTypes are not comparable. Confirm the filter matches intent before flagging a breach.

Pre-flight safety checks (run before any remediation CLI)

  • MANDATORY CONFIRMATION GATE. Before any state-changing operation (CreateBudget, CreateNotification, CreateSubscriber, DeleteNotification, SetTopicAttributes on an SNS policy, PutBudgetAction), the auditor MUST emit: CONFIRM: About to <action> on budget <name> in account <account>. This affects <consequence>. Proceed? (yes/no) Do NOT execute the CLI command until the operator confirms. Budgets changes can suppress or duplicate live alerting.
  • Confirm the caller identity has budgets:Create* and sns:SetTopicAttributes if remediation is intended — most read-only auditor roles CANNOT, and remediation commands will fail with AccessDenied. Surface this BEFORE the operator approves.
  • Before modifying an SNS topic policy, capture the current policy for rollback: `aws sns get-topic-attributes --topic-arn <arn> --region us-east-1

    /tmp/<topic>-policy-backup-$(date +%s).json`. SNS topic policies are not versioned — a bad policy statement can break ALL topic publishers, not just Budgets.

  • Prefer additive changes (add a notification, add a topic-policy statement) over destructive changes (delete a notification, replace a policy). Additive changes are reversible and cannot break existing delivery.
  • Before creating a zero-spend budget on a new account, confirm the account has no expected spend (a zero-spend budget with legitimate ongoing spend generates constant false-positive alerts). For sandbox accounts with small expected spend, use a $1 or $5 guardrail, not $0.01.

Remediation guidance

Ordering principle: always prefer additive changes. Add a notification before deleting one; add a topic-policy statement before rewriting the policy. This prevents a window where no alerting is in effect.

For NO_BUDGET — account has zero budgets

  1. Create a total-account MONTHLY cost budget at the operator's expected monthly spend: aws budgets create-budget --account-id <id> --budget file://total.json --notifications-with-subscribers file://subs.json --region us-east-1
  2. Add at minimum: ACTUAL 50%, FORECASTED 80%, ACTUAL 100% notifications wired to an SNS topic (with the budgets principal in its policy) or an email.
  3. For new/sandbox accounts, additionally create a zero-spend guardrail (Step 7).
  4. For Organizations/consolidated-billing, create a payer-level budget AND per- member budgets (or filtered payer budgets) for chargeback visibility.

For NO_ALERT — budget has zero functional notifications

  1. Create notifications: aws budgets create-notification --account-id <id> --budget-name <name> --notification <json> --subscribers <json> --region us-east-1.
  2. Minimum set for a MONTHLY COST budget: ACTUAL 50% (awareness), FORECASTED 80% (action), ACTUAL 100% (breach). Wire each to an SNS topic or email.
  3. Confirm the SNS topic policy grants budgets.amazonaws.com publish (see CONFIG_GAP / SNS policy remediation).

For CONFIG_GAP — SNS topic policy missing budgets principal (Step 3)

  1. Retrieve the current policy: aws sns get-topic-attributes --topic-arn <arn> --region us-east-1 --query 'Attributes.Policy' --output text.
  2. Add (do not replace) a statement granting the budgets principal publish:
    aws sns set-topic-attributes --topic-arn <arn> --region us-east-1 \
      --attribute-name Policy --attribute-value '<updated-policy-json-with-budgets-statement>'
    
  3. Verify delivery by triggering a test budget notification or waiting for the next threshold crossing and checking CloudTrail for a Publish event from budgets.amazonaws.com.

For CONFIG_GAP — single threshold / no early warning (Step 4)

  1. Add a 50% ACTUAL notification (awareness) and an 80-90% ACTUAL or FORECASTED notification (action tier) via create-notification.
  2. Keep the existing 100% notification as the breach tier. Do NOT delete it.
  3. Confirm total notifications do not exceed 11 per budget.

For CONFIG_GAP — no FORECASTED notification (Step 5)

  1. Add a FORECASTED notification at 80% and/or 100% via create-notification --notification ... --notification-type FORECASTED.
  2. This provides lead time that ACTUAL-only alerts cannot, given cost-data lag.

For CONFIG_GAP — zero-spend guardrail missing (Step 7)

  1. Create a COST budget with BudgetLimit.Amount: 0.01 (or 1.00 for sandbox with tiny expected spend), TimeUnit: MONTHLY, and an ACTUAL 100% notification wired to an SNS topic or email.
  2. Name it distinctly (e.g., zero-spend-guardrail) so it is recognizable in audits.

For OK

  1. No remediation required for current posture.
  2. Recommend verifying the SNS topic policy quarterly — policy drift from other tooling can silently remove the budgets principal.
  3. Recommend confirming email subscribers are still valid (personnel churn).
  4. For Organizations, verify member accounts have independent alerting, not just payer-level coverage.

Deep reference: AWS Budgets internals

Internals deep dive (notification delivery pipeline, cost data lag, quotas) moved verbatim to references/advanced-patterns.md. Load on demand when explaining why a verdict fired or planning notification changes.

Recent AWS features (2024-2026)

Moved verbatim to references/advanced-patterns.md. Load on demand to check 2024-2026 Budgets feature coverage.

References (load on demand)

Domain

AWS CloudOps / FinOps Cost Control & Spend Visibility.

AWS documentation

04 同仓库更多 Skills

jhkchan
jhkchan/aws-agent-skills

xray-tracing-deployer

Deploys AWS X-Ray distributed tracing with production-grade configuration: X-Ray daemon deployment (EC2 systemd, ECS sidecar, EKS DaemonSet, Lambda built-in), SDK instrumentation (Java, Python, Node.js, Go, .NET) with annotations and metadata, sampling rules (default reservoir + rate vs custom rules with URL / method / service-name predicates), service map generation, trace query and retrieval, groups and insights, CloudWatch ServiceLens integration, IAM permissions (PutTraceSegments, GetSamplingRules), and latest features (Lambda Powertools tracing, OpenTelemetry / ADOT Collector support, W3C trace context). Emits a READY_TO_DEPLOY checklist with every configuration item verified. Use when enabling X-Ray on a new application, adding tracing to ECS / EKS / Lambda, validating a sampling configuration, or generating daemon deployment CLI and IaC templates. Triggers: X-Ray, distributed tracing, X-Ray daemon, sampling rules, service map, X-Ray SDK, OpenTelemetry, ADOT, Lambda Powertools, CloudWatch ServiceLens.

★ 4
jhkchan
jhkchan/aws-agent-skills

wellarchitected-workload-auditor

Audits AWS Well-Architected Tool workloads for review staleness, per-pillar high-risk issue counts, milestone tracking gaps, and remediation plan completeness. Emits a deterministic verdict (STALE_REVIEW | HIGH_RISK | CONFIG_GAP | OK) per workload with per-pillar risk breakdown, milestone trend analysis, and specific remediation. Use when reviewing Well-Architected workloads, checking WA review freshness, auditing high-risk issues per pillar, validating milestone coverage, or tracking remediation plans.

★ 4
jhkchan
jhkchan/aws-agent-skills

wellarchitected-review-operator

Operates AWS Well-Architected Tool reviews end-to-end — creates workloads, runs pillar reviews (operational excellence, security, reliability, performance, cost optimization, sustainability, Prosperity), answers questions with risk-tier rationale, generates reports and improvement plans, creates milestones, and integrates with Trusted Advisor and Well-Architected Labs. Runs deterministic pre-checks (workload existence, lens availability, pillar coverage), emits the exact update-answer / get-consolidated-report CLI behind a CONFIRM gate, and verifies risk-tier transitions. Emits READY | BLOCKED | COMPLETED. Use when creating a workload, answering pillar questions, generating an improvement plan, creating a milestone, or integrating with Trusted Advisor. Triggers: well-architected tool, well architected review, workload review, pillar, operational excellence, security, reliability, performance, cost optimization, sustainability, prosperity, improvement plan, milestone, trusted advisor.

★ 4
jhkchan
jhkchan/aws-agent-skills

wafv2-web-acl-deployer

Provisions AWS WAFv2 Web ACLs with correct production defaults: scope selection (CLOUDFRONT vs REGIONAL), managed rule groups (AWSManagedRulesCommonRuleSet, SQLiRuleSet, LinuxRuleSet, WindowsRuleSet, IPReputationList, BotControlRuleSet, AmazonIpReputationList, ATP), custom rules (byte match, IP set, regex pattern, geo match, size constraint, rate-based), rule priority ordering, logging destinations (Kinesis Firehose, CloudWatch Logs, S3), resource association (ALB, API Gateway, CloudFront), rate-based rules with aggregate keys (IP, forwarded IP), Challenge and CAPTCHA actions, and account takeover prevention. Emits a READY_TO_DEPLOY checklist. Use when creating a Web ACL, attaching managed rules, configuring rate limiting, enabling WAF logging, associating a Web ACL with an ALB/API Gateway/CloudFront, or configuring CAPTCHA/Challenge actions. Triggers: create WAF Web ACL, WAFv2, managed rule groups, WAF rate limiting, WAF logging, WAF CAPTCHA, WAF Challenge action, bot control, ATP managed rules.

★ 4
jhkchan
jhkchan/aws-agent-skills

wafv2-web-acl-auditor

Audits AWS WAFv2 Web ACL configurations to determine whether the ACL provides effective protection: default-action posture (Allow vs Block), managed-rule-group coverage gaps, rule effectiveness (BLOCK vs COUNT, shadow/bypass rules, stale exclusions), rate-based rule correctness, logging and visibility configuration, and text-transformation bypass vectors. Emits a deterministic verdict per Web ACL. Use when reviewing a WAFv2 Web ACL for security posture, checking managed-rule coverage, validating rate-limit configuration, auditing WAF logging, or hardening a WAF before production deployment. Triggers: WAF, WAFv2, Web ACL, managed rule group, AWSManagedRules, rate-based rule, CAPTCHA, Challenge, OverrideAction, Count mode, forwarded IP, Bot Control, ATP, text transformation, WAF logging, WAF visibility, OWASP, SQLi, XSS, RFI.

★ 4
jhkchan
jhkchan/aws-agent-skills

waf-rule-deployer

Provisions AWS WAFv2 rule sets with production defaults: Web ACL creation (CloudFront scope in us-east-1 vs Regional scope), rule groups (managed vs custom) with capacity planning in WCU (Web ACL Capacity Units, 1500 default per ACL), managed rule groups (AWSManagedRulesCommonRuleSet, AWSManagedRulesSQLiRuleSet, AWSManagedRulesAmazonIpReputationList, AWSManagedRulesLinuxRuleSet, AWSManagedRulesWindowsRuleSet, AWSManagedRulesUnixRuleSet), custom rules (byte-match, regex pattern set, geo-match, rate-based), IP set and regex pattern set resources, rule priority ordering (lowest number evaluated first), action types (allow, block, count, CAPTCHA, Challenge), bot control managed rule group, account takeover. Triggers: create WAF rule, WAF managed rule group, WAF custom rule, WAF byte match, WAF geo match, WAF rate based rule, WAF IP set, WAF regex pattern set, WAF WCU budget, WAF CloudFront ACL, WAF logging Kinesis Firehose, WAF bot control, WAF ATP, WAF label matching, WAF Challenge action, WAF CAPTCHA.

★ 4