lean-router

Stars4

Forks0

UpdatedJuly 18, 2026 at 15:25

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.

Installation

Install with Codex or Claude Copy this prompt, paste it into Codex, Claude, or another assistant, and let it review the skill page and install it for you.

Source

navveenb

navveenb/lean-agentic-ai-skills

View GitHub Repository View Creator Repositories

Download

Related occupationsSOC

Based on SOC occupation classification

Computer Occupations, All OtherComputer and Mathematical Occupations·SOC 15-1299

File Explorer

3 files

SKILL.md

readonly

More from this repository

same repository

agentic-loop-auditor

navveenb/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.

2026-07-184

ai-eval-efficiency-audit

navveenb/lean-agentic-ai-skills

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.

2026-07-184

api-efficiency-audit

navveenb/lean-agentic-ai-skills

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.

2026-07-184

caching-strategy-designer

navveenb/lean-agentic-ai-skills

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.

2026-07-184

carbon-aware-scheduler

navveenb/lean-agentic-ai-skills

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.

2026-07-184

carbon-budget-designer

navveenb/lean-agentic-ai-skills

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.

2026-07-184

name

lean-router

description

Green Router

The orchestrator for the Lean Agentic AI Skills. It does one job well: turn a user request into a pipeline of single-purpose sustainability skills, wired together through the shared lean-findings.json contract.

The composition model (read this first)

Every skill in the suite is either a producer, a consumer, or a transformer of the shared findings format defined in schemas/lean-findings.schema.json (sibling directory to this suite's skills; a copy ships in references/lean-findings.schema.json).

Producers (audits): web-carbon-audit, cloud-waste-audit, green-code-review, agentic-loop-auditor, ... Each emits one lean-findings.json.
Consumers (outputs): lean-deck-builder, lean-report-writer, sci-receipt, lean-dashboard. Each accepts one or more findings files.
Transformers: merge, filter, or re-rank findings between the two.

Because producers and consumers only speak through the contract, any audit can feed any output format. The router's job is picking the chain, not doing the work.

Routing procedure

Classify the request along two axes:
- Subject: website | codebase | cloud account | AI/LLM pipeline | CI pipeline | database | architecture design | document/output only
- Intent: audit (find problems) | generate (build something green) | report (communicate findings) | schedule (time-shift work) | mixed

Select the pipeline. Common shapes:

User says	Pipeline
"Is my website green?"	`web-carbon-audit` → inline summary
"Audit our site and make a deck for leadership"	`web-carbon-audit` → `lean-deck-builder`
"Audit cloud spend and our website, one report"	`cloud-waste-audit` + `web-carbon-audit` → merge → `lean-report-writer`
"Are our instances oversized?"	`right-size-compute` (+ `container-density-audit` if k8s)
"Should this VM be a Lambda?"	`vm-to-serverless-advisor`
"Storage costs keep growing"	`storage-lifecycle-audit` (+ `data-minimization-designer` for the greenfield fix)
"The database is slow and hot"	`db-efficiency-audit` (→ `caching-strategy-designer` if uncached repeats found)
"CI takes forever"	`lean-ci-audit`
"Make our chatbot cheaper/greener"	`model-right-sizer` + `prompt-carbon-optimizer` + `llm-cache-designer` → `sci-receipt`
"Our agent burns tokens"	`agentic-loop-auditor` → `sci-receipt`
"Where should we deploy / when should batches run?"	`region-selector` / `carbon-aware-scheduler`
"Track findings over time"	existing findings files → `lean-dashboard`
"This will be printed for the board"	any output → `print-conscious-formatter`
"Training is slow/expensive"	`training-efficiency-audit` (+ `carbon-aware-scheduler` pairing)
"Our RAG answers cost too much"	`rag-pipeline-optimizer` → `sci-receipt`
"The app drains battery/data"	`lean-mobile-audit`
"We stream a lot of video"	`video-streaming-optimizer`
"Observability bill keeps growing"	`logging-telemetry-audit`
"Did we improve since last audit?"	`findings-diff` (→ `lean-dashboard` for the trend)
"Fail the build if we regress"	`lean-regression-gate` setup
"We want actual carbon numbers"	`impact-framework-bridge`
"Set efficiency targets for teams"	`carbon-budget-designer`
"Our Spark/dbt pipelines are heavy"	`data-pipeline-audit`
"Why is our JavaScript bundle huge?"	`js-bundle-audit`
"Clients hammer our API"	`api-efficiency-audit`
"Image generation costs too much"	`genai-media-optimizer` → `sci-receipt`
"Add an eco mode to the product"	`demand-shaping-designer`
"Should we refresh the laptop fleet?"	`hardware-lifecycle-advisor`
"Put the findings in Jira/GitHub"	`findings-to-tickets`
"Big picture across all our repos"	`portfolio-aggregator` → `lean-deck-builder`/`lean-report-writer`
"Write the release notes for what we fixed"	`findings-diff` → `lean-changelog`
"Review this contributed skill"	`skill-conformance-checker`
"Our evals are slow/expensive"	`ai-eval-efficiency-audit`
"Serve more tokens per GPU"	`llm-serving-optimizer`
"Should we fine-tune or just prompt better?"	`fine-tune-vs-prompt-advisor`
"Our Electron app drains laptops"	`desktop-app-audit`
"Tune our existing Lambdas"	`serverless-function-tuner`
"Our newsletter is heavy / list is dead"	`email-campaign-audit`
"Teach the team from these findings"	`lean-education-builder`

If a needed skill is not installed, say so plainly, do the best honest job inline, and mark the gap in out_of_scope.

Right-size effort per hop. The router practices what the suite preaches:
- Classification and data extraction are cheap steps — do them tersely, no extended deliberation.
- Reserve deep reasoning for synthesis-heavy steps (writing the report narrative, designing an architecture).
- Never re-run an audit whose findings file already exists in the workspace for the same subject — reuse it and say you did. Cache-first is a green pattern too.
- Cap pipelines at what the request needs. "Is my site green?" does not need a deck.
Run the pipeline. For each step, read that skill's SKILL.md and follow it. Persist each producer's output as <subject-slug>.lean-findings.json in the working directory so later steps (and later conversations) can reuse it.
Merge when multiple producers ran. Merging is mechanical:
- Concatenate findings arrays; keep each finding's original producer traceable by prefixing id with the skill name if the same id appears in multiple files.
- Union passed and out_of_scope.
- Keep every methodology paragraph — consumers must present all of them.
- Never de-duplicate across subjects (an image problem on two sites is two findings).
Close with a one-line receipt of what ran: skills invoked, findings counts by severity, and where the findings files live. Keep it to 1–2 sentences unless the user asked for detail.

Honesty rules (inherited by every pipeline)

These are suite-wide and non-negotiable; repeat them to downstream skills if there is any doubt:

Never invent numbers — but distinguish what can and cannot be counted. Wasted compute has three symptoms: energy (E), cost, and carbon. Energy and carbon impact stay directional by design — no "saves 47% energy" or CO2e grams without measurement. But cost drivers often can be counted from static analysis (tokens, GB, instance-hours, requests, file counts). When a driver is countable, name it in the finding's optional cost_signal field: {driver, observed, direction}. Never convert a counted driver into a dollar figure without the user's billing rate — the driver is the honest currency. For measured energy/carbon numbers, point users to CodeCarbon, Cloud Carbon Footprint, Kepler, or the GSF Impact Framework.
Surface trade-offs. Caching adds staleness; carbon-aware scheduling adds latency; edge inference shifts embodied carbon to client devices. Name them.
Refuse patterns that context makes wrong. Real-time systems shouldn't be batched; tiny internal tools don't need SSR.
Every report carries its methodology. If a consumer skill receives findings without a methodology field, ask the producer step to add one or write an honest caveat.

What this skill is not

Not a measurement tool — it orchestrates estimates and pattern audits, not meters.
Not a substitute for the individual skills: it should stay thin. If the router starts containing audit logic, that logic belongs in a skill.