Teaching AI Efficiency: From Concept to Practice
In the last edition of Technology Bytes, I wrote about something our industry has been overlooking — one of the most important AI skills of all.
Efficiency.
Not efficiency as an afterthought. Efficiency as a skill that every AI agent should learn from the very beginning.
That article ended with a promise: to move from concept to practice.
Because the concept raises an obvious question:
How do you actually teach an agent to be efficient?
Today, I want to answer that question. And I want to answer it with something you can use — starting today.
Skills Are Now Installable
The agent ecosystem has quietly converged on something important: a common way to package expertise.
It’s called Agent Skills — a simple, portable way to package expertise that is rapidly being adopted across AI coding agents.
A skill is just a folder containing a Markdown file. It describes when the skill applies, what to check, and how to behave. The agent reads it when relevant and follows it — no fine-tuning, no retraining, no platform lock-in.
The same skill folder now works across Claude, OpenAI Codex, GitHub Copilot, Google Antigravity, Cursor, Gemini CLI, and a growing list of agent platforms.
Pause on what that means.
If expertise can be written down, it can be installed.
If it can be installed, it can be shared.
And if it can be shared, it can become the collective intelligence of every AI agent.
Which means efficiency — the engineering judgment I described last time, knowing when less is enough — doesn’t have to remain an abstract aspiration.
It can be packaged. Shared. Taught.
So that’s exactly what I did.
Introducing Lean Agentic AI Skills
Today I’m open-sourcing Lean Agentic AI Skills: a suite of composable agent skills for reducing cost, carbon, energy, and complexity — across your web, cloud, data, and AI stack.
It’s the executable companion to my book, Lean Agentic AI: Minimizing Cost, Carbon, and Complexity, published last year. It’s free, MIT licensed, and it leverages Green Software Foundation patterns and the SCI (Software Carbon Intensity) framing.
The design follows three simple ideas.
One skill, one job.
There is no giant “efficiency analyzer.” There’s a focused specialist for each domain: a web page auditor, a cloud waste auditor, a database efficiency auditor, a prompt optimizer, an agent loop auditor, a training efficiency auditor — each one packaging what an expert in that domain would actually look for.
A router that thinks lean.
You never memorize skill names. One skill — the router — reads your question and brings in the right specialist. And it practices what it preaches: simple steps get quick thinking, hard steps get deep thinking, and finished audits are reused instead of re-run.
One shared contract.
Every audit writes its results in the same simple format: a findings file. That one decision is the magic. Any audit can feed any output — a slide deck for leadership, a written report, a live dashboard, sprint tickets, or a two-line summary for your release notes. Add a new audit skill, and every output skill works with it instantly.
AI Skills Are the New Design Patterns
Software engineering has always evolved by capturing expertise and making it reusable.
1990s — Object-Oriented Design Patterns
2000s — Frameworks & Libraries
2010s — Cloud & Microservice Patterns
2020s — Agentic AI Skills
Each generation packaged more expertise.
The difference is that this time, we’re packaging expertise for AI agents instead of developers.
Instead of teaching developers how to build better software, we’re teaching AI agents how to make better decisions.
Instead of reusable code, we’re creating reusable expertise.
Instead of documenting best practices, we’re making them installable.
That’s why I believe AI Skills will become the design patterns of the Agentic AI era.
The first chapter of Agentic AI was about building capable agents.
The next chapter is about building skilled agents.
Skills become the reusable building blocks of Agentic AI — just as design patterns became the reusable building blocks of modern software engineering.
What Teaching Efficiency Actually Looks Like
Let me make this concrete.
Ask your agent: “Make our chatbot cheaper.”
Three skills team up. One examines whether every request really needs your largest model. One examines the prompt itself — and finds five few-shot examples where two would hold quality, instructions repeated three different ways, and dynamic content placed exactly where it breaks provider caching. One designs a cache so the same fifty questions your users ask every day stop triggering fresh inference every time.
In a typical case, the system prompt alone shrinks from roughly 370 tokens to 110 — on every single call, at production volume.
And here’s the part I care most about.
The final summary tells you: tokens counted, from your own logs. Energy and carbon impact: directional, by design.
No invented percentages. No fabricated savings figures. No vague “green scores.”
That’s not a limitation. That’s the feature.
Honesty Is the Curriculum
Sustainability and efficiency claims carry weight. The fastest way to lose an engineering leader’s trust is to show them a number that was made up.
So every skill in the suite follows the same rules:
If something can be counted — tokens, gigabytes, instance-hours, idle servers — it gets counted and shown, with its source.
If something can’t be measured statically — energy, carbon — the language stays directional, and the report points you to the real measurement tools that can confirm it.
Trade-offs are always named. Caching adds staleness. Scheduling adds latency. Every recommendation says what it costs.
And when a system is already well built? The audit says so. A thin, honest report on a healthy system is a pass — not a failure of the tool.
This is what I mean by teaching judgment, not just capability. The skills encode the discipline, so every agent that loads them inherits it.
How Organizations Can Start
You don’t need a transformation program. You need one question.
Start where the pain is. “Lower our cloud bill.” “Why is CI so slow?” “Our AI spend doubled.” Attach the relevant export — a billing file, a workflow config, your prompts — and let the right skill investigate. Every finding comes ranked by effort, so the quick wins surface first.
Make results flow. The same findings become a leadership deck on Monday, sprint tickets on Tuesday, and a dashboard the team updates all quarter. Efficiency work that ends as a PDF decays. Efficiency work that ends as a backlog gets burned down.
Then make it stick. The suite includes a regression gate for CI — if a change reintroduces waste, the build fails. Efficiency stops being a one-time audit and becomes a standing property of your engineering system, the same way tests and performance budgets did.
That’s the progression: one question, one pipeline, one gate. Concept to practice in three steps.
Why This Matters Now
In the last edition, I wrote that the winners in Agentic AI will be the systems that deliver the right business outcome while consuming the least compute, cost, energy, time, and complexity.
I believe the same is true for the organizations behind them.
Wasted compute shows up as three symptoms of one problem: energy consumed, money billed, carbon emitted. The same oversized instance, the same bloated prompt, the same uncached inference — charged three ways, in the same act.
Which means every efficiency skill your agents learn pays back three ways too.
Finance sees the savings. Engineering sees the simplification. Sustainability sees the impact.
One audit. Three payoffs.
Try It
Everything is available today. The initial release includes 49 production-ready skills covering web, cloud, data, software engineering, AI systems, and sustainability — plus the shared contract, the evaluation suite, and full documentation. Free and MIT licensed.
GitHub Repository https://github.com/navveenb/lean-agentic-ai-skills
Documentation & Skills Catalog https://leanagenticai.com/skills/
Install the router and one auditor. Ask one question about a system you own. See what your agent finds.
And if you have expertise the catalog is missing — a domain, a pattern, a discipline — contributing a skill is one folder. The suite even includes a skill that reviews new skills against its own standards.
Your knowledge becomes something every agent can use.
Final Thoughts
For decades, software engineering has advanced by turning experience into reusable patterns.
I believe Agentic AI will evolve the same way.
Not through larger models.
Not through longer prompts.
But through installable expertise.
That’s what Lean Agentic AI Skills is about. A place where the best practices of experienced engineers become reusable skills that every AI agent can learn.
Because the future won’t belong to the agents with the most intelligence.
It will belong to the agents with the most skill.
Explore the project:
GitHub Repository https://github.com/navveenb/lean-agentic-ai-skills
Documentation & Skills Catalog https://leanagenticai.com/skills/
I’d love to hear what you think — and even more, I’d love to see the skills our community builds next.