lean-agentic-ai-skills

Audit agent frameworks and agentic workflows for token-burning loop pathologies — unbounded retries, excessive planning depth, tool-call thrashing, context snowballing, missing loop budgets and kill switches. Use this skill whenever the user shares agent configs or traces (LangChain/LangGraph, CrewAI, AutoGen, custom loops), complains an agent is slow or expensive, or is designing any autonomous/multi-step agent. Part of Lean Agentic AI Skills; emits lean-findings.json.

Audit AI evaluation infrastructure for wasted compute — full benchmark suites re-run on unchanged cases, LLM-as-judge grading without caching, oversized judge models, redundant eval passes per commit, and missing result reuse. Use this skill whenever the user shares eval harness configs or CI eval steps, complains that evals are slow or expensive, mentions LLM-as-judge costs, or runs benchmark suites on every change. Part of Lean Agentic AI Skills; emits lean-findings.json.

Audit API design for chattiness and over-fetching — REST endpoints requiring N calls per screen, GraphQL resolvers with N+1 fan-out, default-everything payloads, missing pagination and field selection, provider-side polling where webhooks serve, and uncompressed responses. Use this skill whenever the user shares API schemas (OpenAPI, GraphQL SDL), resolver code, endpoint designs, or asks why clients make too many calls or payloads are heavy. Part of Lean Agentic AI Skills; emits lean-findings.json.

Design caching layers so work is done once, not per request — HTTP/CDN caching, application-level caches (Redis/Memcached), computed-result caching, and cache-invalidation strategy. Use this skill whenever the user wants to add caching, asks why the same work is recomputed, designs a read-heavy system, or an audit skill (db-efficiency-audit, web-carbon-audit) flags uncached repeated work. Part of Lean Agentic AI Skills; emits a cache design plus lean-findings.json.

Design time-shifting of flexible workloads (batch jobs, CI, training, backups, crons) to hours and regions when grid electricity is cleanest, using carbon-intensity signals like Electricity Maps, WattTime, or the Carbon Aware SDK. Use this skill whenever the user mentions carbon-aware computing, scheduling flexible/deferrable jobs, demand shifting, running workloads when energy is clean, or asks how to reduce the carbon intensity (not just amount) of their compute. Part of Lean Agentic AI Skills; emits schedule designs plus lean-findings.json.

Design per-feature and per-service efficiency budgets — page-weight budgets, token budgets per AI feature, query budgets per endpoint, GPU-hour budgets per training project — with owners, review checkpoints, and enforcement hooks. Use this skill whenever the user wants sustainability targets for teams, asks how to keep efficiency from regressing organizationally, mentions performance-budget-style governance for carbon/energy, or is setting engineering standards. Part of Lean Agentic AI Skills; an advisor emitting budget definitions plus lean-findings.json.

Find idle and orphaned cloud resources that burn money and carbon for no output — idle VMs, unattached disks/volumes, unassociated elastic IPs, zombie snapshots, forgotten load balancers, stopped-but-billed instances. Use this skill whenever the user shares cloud billing exports or resource inventories (AWS Cost Explorer/CUR, Azure Cost Management, GCP billing) and the question is about unused or forgotten resources — idle instances, waste, things running that shouldn't be — cost and carbon are two payoffs of the same fix. For costs driven by growing stored data, retention, or tiering (S3/blob bills, Storage Lens reports, "we never delete anything"), use storage-lifecycle-audit instead. Part of Lean Agentic AI Skills; emits lean-findings.json for composition with report/deck skills.

Audit Kubernetes/container clusters for poor bin-packing — inflated resource requests vs actual usage, low node utilization, missing autoscaling, pods hoarding capacity. Use this skill whenever the user shares k8s manifests, kubectl top / metrics-server output, cluster utilization data, or asks about node counts, pod density, cluster efficiency, or Kubernetes sustainability. Part of Lean Agentic AI Skills; emits lean-findings.json.

Design systems to collect, transfer, process, and retain less data — payload slimming, field-level collection review, sampling strategies, aggregation-at-source, and retention-by-design. Use this skill whenever the user designs telemetry/analytics/logging pipelines, asks what data to collect, mentions data hoarding or GDPR-style minimization, or builds APIs whose payloads carry unused fields. Part of Lean Agentic AI Skills; emits lean-findings.json plus a minimization design.

Audit data engineering workloads for compute waste — Spark shuffle explosions, small-files problems, missing partition pruning and predicate pushdown, row formats where columnar belongs, full-refresh pipelines that should be incremental, and dbt models rebuilding unchanged upstreams. Use this skill whenever the user shares Spark/ETL/warehouse jobs, dbt projects, Airflow DAGs, query plans from Snowflake/BigQuery/Databricks, or asks why data pipelines are slow, expensive, or heavy. Part of Lean Agentic AI Skills; emits lean-findings.json.

Audit database workloads for energy-wasting query and schema patterns — full table scans, missing indexes, SELECT * over-fetching, N+1 query storms, chatty ORMs, oversized instances, missing connection pooling. Use this skill whenever the user shares slow-query logs, EXPLAIN plans, ORM code, schema DDL, or asks why the database is slow/expensive/hot, or wants a database efficiency or sustainability review. Part of Lean Agentic AI Skills; emits lean-findings.json.

Design carbon-responsive experience tiers — gracefully reducing quality or deferring non-essential features when grid carbon intensity is high (eco modes, adaptive quality, deferred background work), the demand-shaping half of carbon-aware design. Use this skill whenever the user wants an eco mode, asks how the product itself can respond to dirty-grid hours, mentions demand shaping or carbon-aware UX, or wants the product experience itself to respond to grid conditions. Part of Lean Agentic AI Skills; emits a shaping design plus lean-findings.json.

Audit desktop applications — especially Electron and other web-runtime apps — for idle resource waste: background CPU when unfocused, memory footprint, startup daemons, per-app runtime duplication, animation and polling loops that never sleep. Use this skill whenever the user builds or maintains a desktop app, mentions Electron/Tauri/WebView apps, shares process or profiler data, or users complain the app drains laptops. Part of Lean Agentic AI Skills; emits lean-findings.json.

Audit email campaigns and transactional email for weight and waste — heavy image templates, remote assets fetched per open, tracking-pixel sprawl, missing plain-text alternatives, send-volume hygiene (unengaged segments, over-frequency). Use this skill whenever the user shares email templates or campaign stats, works on newsletters or transactional email at scale, or asks about email sustainability, deliverability weight, or list hygiene. Part of Lean Agentic AI Skills; emits lean-findings.json.

Compare two lean-findings.json files for the same subject across time and report real progress deltas — findings resolved, new, persisting, and severity shifts. Use this skill whenever the user asks "did we improve", "compare this audit to the last one", wants progress since a previous audit, or re-runs an audit on a subject that already has a findings file. Part of Lean Agentic AI Skills; a transformer — emits a diff report plus a merged findings file with status annotations.

Convert lean-findings.json into a ready-to-import sprint backlog — GitHub Issues, Jira, or Linear tickets with severity labels, effort estimates, acceptance criteria, and pattern links. Use this skill whenever the user wants audit findings as tickets/issues/backlog items, asks to "make this actionable" or "put these in Jira/GitHub", or wants remediation work assigned to a sprint. Part of Lean Agentic AI Skills; a transformer from findings to work items.

Decide the cheapest path to an AI capability — prompting, RAG, fine-tuning, or distillation — with the honest amortization math for each. Use this skill whenever the user asks "should we fine-tune", weighs prompt engineering against training a custom model, wants a capability at lower ongoing cost, or is designing a new AI feature and choosing its approach. Part of Lean Agentic AI Skills; emits lean-findings.json.

Optimize generative image/video/audio workloads — inference step counts, distilled/turbo model variants, generate-small-then-upscale strategies, batching, seed reuse, and cache-vs-regenerate policy for repeated assets. Use this skill whenever the user runs diffusion or generative media models (Stable Diffusion, image/video/audio generation APIs), shares generation configs, or asks how to cut the cost or footprint of AI-generated media. Part of Lean Agentic AI Skills; emits lean-findings.json.

Extend hardware life and right-size procurement — the embodied-carbon (M) specialist. Audits device-support windows that force early replacement, software bloat that obsoletes working hardware, fleet refresh cycles, and advises on refurbished/right-sized procurement. Use this skill whenever the user discusses device fleets, minimum system requirements, OS/browser support windows, hardware refresh policies, procurement, or why old devices can't run their software. Part of Lean Agentic AI Skills; emits lean-findings.json.

Export Lean Agentic AI Skills findings into Green Software Foundation Impact Framework (IF) manifests — turning directional findings into a measurement plan that IF can compute with real observations. Use this skill whenever the user wants actual measured numbers — "what is our real carbon figure", "leadership wants a number, not directional language", an emissions value for a system — or mentions the Impact Framework / IF / impact manifests, asks how to go from this module's findings to measured carbon, or wants a measurement plan for audited systems. This skill is the module's route from directional findings to computed figures; qualitative summaries belong to sci-receipt. Part of Lean Agentic AI Skills; a transformer from lean-findings.json to IF manifest scaffolds.

Decide where AI inference should run — edge/on-device vs cloud, batch vs realtime, GPU vs CPU — with the embodied-carbon trade-offs named honestly. Use this skill whenever the user asks whether to run models on-device/locally/at the edge or in the cloud, whether to batch inference jobs, or how to serve a model efficiently. Part of Lean Agentic AI Skills; emits lean-findings.json.

Audit frontend build output for shipped-code waste — bundle size, dead code, missing code-splitting, hydration cost on content pages, duplicate dependencies, and polyfills for unsupported browsers. Use this skill whenever the user shares a build stats file (webpack/Vite/Rollup stats, source-map-explorer output), package.json + bundler config, or asks why the site's JavaScript is heavy or slow to load. Part of Lean Agentic AI Skills; emits lean-findings.json.

Turn findings-diff results into release-notes prose — short, honest "sustainability improvements in this release" sections for changelogs, release announcements, and internal newsletters. Use this skill whenever the user wants to communicate efficiency progress in a release, asks for changelog/release-notes text about green improvements, or wants findings-diff output made publicly legible. Part of Lean Agentic AI Skills; a transformer from diff results to publishable prose.

Audit CI/CD pipelines for wasted compute — uncached builds, full test suites on every commit, redundant matrix jobs, artifacts and images kept forever, scheduled jobs running when nothing changed. Use this skill whenever the user shares CI configs (GitHub Actions, GitLab CI, Jenkins, CircleCI), complains about slow/expensive pipelines, or asks for a CI/CD efficiency or sustainability review. Part of Lean Agentic AI Skills; emits lean-findings.json.

Build an interactive HTML dashboard tracking sustainability findings and remediation over time — severity breakdowns, effort-vs-impact matrix, per-audit drill-down, and remediation status. Use this skill whenever the user wants to visualize or track Lean Agentic AI Skills audit results, monitor remediation progress across sprints, or present findings interactively rather than as a static report or deck. Consumes one or more lean-findings.json files; never audits anything itself.

Turn sustainability audit findings into a polished stakeholder presentation (.pptx). Use this skill whenever the user wants a deck, slides, or presentation from any Lean Agentic AI Skills audit (web-carbon-audit, cloud-waste-audit, green-code-review, etc.), asks to "present the findings", needs a leadership/board/client-facing summary of a green or efficiency audit, or a lean-router pipeline ends in a presentation. Consumes one or more lean-findings.json files — never audits anything itself.

Turn audit findings into team learning material — workshop outlines, lunch-and-learn decks, onboarding modules, and quizzes built from your own codebase's real findings. Use this skill whenever the user wants to teach their team green/efficient practices, asks for training or workshop content from audit results, wants engineering onboarding to cover efficiency, or says "help the team learn from this". Consumes lean-findings.json from any Lean Agentic AI Skills audit; never audits anything itself.

Audit mobile apps for battery and network waste on user devices — wake locks, background sync frequency, polling where push serves, location over-sampling, image/payload sizes on cellular, and retry storms on flaky networks. Use this skill whenever the user shares Android/iOS code or configs (WorkManager, background tasks, sync adapters), asks why an app drains battery or data, or wants a mobile app sustainability/efficiency review. Part of Lean Agentic AI Skills; emits lean-findings.json.

Gate CI on sustainability regressions — compare a fresh audit's findings against a committed baseline findings file and fail the build (or warn) when new high-severity findings appear. Use this skill whenever the user wants sustainability checks in CI/CD, asks to "fail the build if we get less green", wants a merge check for efficiency regressions, or mentions enforcing green budgets automatically. Part of Lean Agentic AI Skills; a transformer designed to run headless in pipelines.

Turn sustainability audit findings into a polished written report (Word/PDF/markdown) — executive narrative, findings detail, remediation roadmap, with optional ESG/CSRD-flavored framing on request. Use this skill whenever the user wants a written sustainability/efficiency report, documentation of audit results, content for an ESG or engineering report, or a lean-router pipeline ends in a document. Consumes one or more lean-findings.json files from any Lean Agentic AI Skills audit; never audits anything itself.

The entry point and orchestrator for the Lean Agentic AI Skills. Use this skill FIRST whenever the user asks anything sustainability-, carbon-, energy-, or efficiency-related about their software, website, cloud, AI pipeline, or wants a green audit, report, deck, or dashboard — even if they don't name a specific skill. Also use it when the user's request spans multiple steps ("audit X and make me a presentation"), when it's unclear which sustainability skill applies, or when the user mentions reducing compute or cloud cost. This skill classifies the request, selects and sequences the right suite skills, right-sizes model effort per step, and merges findings between steps.

Design caching layers in front of LLM inference — exact-match caches, semantic caches, provider prefix caching, and negative caching — so repeated questions never re-burn inference. Use this skill whenever the user mentions repeated/similar LLM queries, wants to cut inference cost or carbon for FAQ/support/RAG workloads, asks about semantic caching, or has any high-volume LLM endpoint. Part of Lean Agentic AI Skills; emits lean-findings.json plus a cache design.

Tune self-hosted LLM serving for efficiency — continuous batching configuration, KV-cache sizing, quantized serving, speculative decoding, replica right-sizing, and GPU utilization per served token. Use this skill whenever the user self-hosts models (vLLM, TGI, TensorRT-LLM, Ollama at scale), shares serving configs or GPU utilization data, or asks how to serve more tokens per GPU. Part of Lean Agentic AI Skills; emits lean-findings.json.

Audit logging, tracing, and metrics pipelines for volume waste — debug-level logging in production, unsampled traces, high-cardinality metrics explosions, duplicate log shipping, and retention without tiers. Use this skill whenever the user shares logging configs (log4j/logback/zap, OpenTelemetry, Prometheus, Datadog/Splunk settings), complains about observability costs, or wants a telemetry efficiency review. Part of Lean Agentic AI Skills; emits lean-findings.json.

Pick the smallest capable model for each AI task — audit LLM/ML usage for oversized model selection, design tiered routing (small model first, escalate on need), and recommend quantization or distillation where relevant. Use this skill whenever the user asks which model to use, wants to cut LLM/API cost, latency, or the carbon footprint of AI features, mentions their AI bill, shares model-usage logs, or is designing any LLM-calling feature. Part of Lean Agentic AI Skills; emits lean-findings.json.

Roll up findings across many subjects into one organization-level view — top waste patterns by frequency, teams/services ranked by open high-severity findings, SCI-term distribution, and portfolio-wide quick wins. Use this skill whenever the user has findings files from multiple audits/repos/teams and asks for the big picture, an engineering-org sustainability posture, a CTO/leadership rollup, or "where should we focus first across everything". Part of Lean Agentic AI Skills; a transformer emitting a portfolio findings summary.

Format documents and decks to be cheap to print and share — ink-light palettes, no full-bleed backgrounds, page-count discipline, print-friendly typography, and lean file sizes. Use this skill whenever a Lean Agentic AI Skills output (report, deck, one-pager) will be printed or widely distributed, the user mentions printing/handouts/PDF distribution, or asks to make a document lighter or more accessible. Works as a transformer on documents produced by other skills or supplied by the user.

Treat prompt engineering as an efficiency discipline — trim few-shot bloat, cap output length, deduplicate system-prompt repetition, structure prompts for prefix caching, and cut token waste per call. Use this skill whenever the user shares prompts or system prompts for review, asks to reduce token usage, cost, or the per-call footprint of a production prompt, mentions prompts feeling bloated, or is writing a prompt for a high-volume production call site. Part of Lean Agentic AI Skills; emits lean-findings.json.

Audit and tune RAG (retrieval-augmented generation) pipelines for compute efficiency — chunk sizing, embedding-model right-sizing, retrieval-k tuning, rerank-only-when-needed, context stuffing, and index refresh cadence. Use this skill whenever the user shares a RAG setup (LangChain/LlamaIndex configs, vector DB settings, retrieval code), complains RAG answers are slow or costly, or is designing document Q&A / knowledge-base search over an LLM. Part of Lean Agentic AI Skills; emits lean-findings.json.

Choose cloud regions with cleaner grids — compare deployment regions on carbon intensity alongside latency, data-residency, price, and service availability, for new deployments or migration candidates. Use this skill whenever the user asks which region/zone to deploy in, mentions moving regions, sets up new infrastructure, or asks about the carbon footprint difference between regions. Part of Lean Agentic AI Skills; emits lean-findings.json.