Posts

The biggest myth in AI today?
That tools like LLMs, CoPilots, MCPs, and Agents will do the engineering for you.
They won’t — because AI is engineering.

LLMs. MCP. Agents. They’re all just that — tools.

Yet many organizations are spending an extraordinary amount of time comparing, evaluating, and switching between tools — while missing the real essence of AI transformation.

The real differentiator isn’t the toolchain.
It’s the engineering mindset behind how those tools are used.

Most organizations miss that AI is an engineering discipline — not a collection of experiments. It demands the same rigor as any mature system: design, development, testing, validation, rollout, and continuous optimization.

Don’t go by leaderboards — they’re tested to work in controlled benchmarks, not in real-world, multi-system environments where context, latency, data, and cost all collide.

And don’t fall for the misconception that AI will replace engineers.
That’s a narrative being set — but having worked with top LLMs and chatbots, one thing is clear: they often fail when confronted with real engineering. Their code lacks depth, structure, and holistic system thinking.

Tools never replace real engineering.
They amplify those who understand it.

Invest in the core.
Invest in robust engineering practices.
Upskill your teams.
This will be your foundation in building scalable, responsible, and future-ready AI systems.

Because tools will change. Frameworks will evolve.
But engineering excellence — that’s what endures

The Agent Economy is taking shape.

Three decades ago, the internet connected systems.
Now, intelligence is connecting decisions.

This week’s edition of Tech Bytes explores how the next digital shift will be engineered — not imagined.

It looks beyond copilots and LLMs to the real foundation of what comes next: orchestration, governance, and the engineering discipline behind the Agent Economy.

Because intelligence may guide the future, but engineering will build it.

🔗 Read the full edition: The Agent Economy: Engineering the Next Digital Shift

Copilots are like humans.
First, they invent a problem.
Then, they proudly solve it.

In practice, that means copilots can generate complexity that wasn’t there before. They might over-engineer a simple task, suggest unnecessary fixes, or loop through steps that lead back to the starting point.

Sounds familiar? It’s the same tendency humans have — turning straightforward problems into puzzles just to prove we can solve them.

The takeaway: Copilots are not magic wands. They need engineering discipline, clear boundaries, and well-defined objectives. Otherwise, we risk spending time solving problems that never existed in the first place.

Agentic AI will only succeed when we design systems that focus on the right problems — not just any problems.

🚀 Agentic AI is 90% Engineering

Building agentic systems is not just about prompts and orchestration. It’s engineering. In fact, Agentic AI is ninety percent engineering.

Think about what makes an agent work in the real world:
-> Planning: Beyond breaking tasks into steps, production systems must handle ambiguity, recover from failures, and avoid runaway loops. That means guardrails, fallback strategies, and lean logic.
-> Memory: Balancing storage, retrieval efficiency, cost, and emissions — too much and the system bloats, too little and it forgets. Getting this right is system design, not prompt magic.
-> Tool Use: APIs fail, data shifts, latency matters. Tools must be cached, reused, or gracefully degraded. That’s engineering discipline.
-> Orchestration: Routing, monitoring, logging, and optimization often take more effort than model interactions themselves.

This is where the real surge will come. As organizations move from flashy demos to production workflows, they’ll face questions of scalability, observability, security, and sustainability.

It will be similar to the early days of cloud adoption. At first, everyone spun up instances and showed quick wins. But the real value only arrived when engineering disciplines matured — infrastructure as code, DevOps, FinOps, security, and resilience. The same arc is unfolding now with Agentic AI. Demos will fade. Engineering will take center stage.

The differentiator won’t be who has the biggest model. It will be who builds the most reliable, efficient, and sustainable systems — who treats cost, energy, carbon, and complexity as first-class citizens, and who designs lean workflows that scale without waste.

✨ The magic of Agentic AI lies not in the spark of the demo, but in the discipline of the build.

🌱 Green Software Agent Researcher — Now Tracking Emissions per Prompt

Six months ago, the Green Software Agent Researcher was launched to make sustainability research smarter and scalable.

Since then, many have asked for environmental metrics to be integrated as part of the workflow. Today, the application takes that step — tracking environmental impact alongside Generative AI workloads. It now calculates emissions per prompt for each LLM model and shows how prompt optimization can reduce the Software Carbon Intensity (SCI).

⚡ Example Impact of Prompt Optimization
(Results vary by query)
-> Input Tokens: 56.2% reduction
-> Output Tokens: 38.5% reduction
-> Total Tokens: 49.4% reduction
-> SCI Score: 59.3% lower compared to the unoptimized run
The application provides a clear before-and-after analysis, showing both efficiency gains and sustainability improvements.

🤖 How it works
👉 Check out the detailed analysis in the generated reports for full transparency into energy, emissions, and SCI calculations. Hopefully one day, we’ll see this kind of transparent reporting across all applications.

🌍 Why it matters
SCI is about more than measurement — it’s about driving reductions in emissions. This use case highlights prompt optimization as one lever to achieve tangible reductions.

✨ Feel free to try out the new feature at https://greensoftware.ai/ and explore the before-and-after analysis. More details coming soon — including other levers like model selection, caching, and execution timing that will expand the path to greener AI.

#greenai Green Software Foundation

🧭 Still searching for your place in the age of AI?

This isn’t just about learning new tools. It’s about unlearning old habits.
As AI transforms how software is designed, built, and maintained — engineers face a new challenge:

How do you lead, adapt, and stay valuable when intelligent machines sit alongside you?

That’s the foundation of The New AI Engineering Mindset — a practical guide I wrote to help engineers, architects, and tech leaders rethink how they design, build, and lead in an increasingly agentic world.

📘 What’s inside:
✅ The Human Stack — A clear framework for defining where engineers create irreplaceable value in AI-augmented systems.
✅ From Prompting to Orchestration — Moving beyond one-shot prompts into structured workflows powered by agents, tools, and intent resolution.
✅ Ethical and Responsible Design — Practical frameworks for prompt engineering, AI ethics, and responsible deployment in production environments.
✅ Gen AI–Driven SDLC — A step-by-step walkthrough of how generative and agentic models are reshaping the software development lifecycle.
✅ From Anxiety to Agency — How to grow with AI, not fear it — through adaptive skills, systems thinking, and intentional collaboration.
✅ Impact Matters — Tracking not just velocity or output, but fairness, quality, and sustainability.

Whether you’re leading AI transformation, modernizing delivery teams, or mentoring future engineers, this mindset is essential for navigating complexity with clarity.
📖 The New AI Engineering Mindset: Navigating Uncertainty and Opportunity in the Age of Intelligent Machines

🔗 Available on Amazon - https://amzn.to/48qxzoF

The hype around AI coding tools needs a reality check.

One of the leading AI copilots I tried went so far as to invent an API. It started building an app around this imaginary API and even pointed me to “documentation” that didn’t exist—completely fabricated.

I then pointed it to the correct documentation, thinking it would recover. Instead, after “reading” it, the copilot fabricated another API. That was the moment I stepped back.

I genuinely wanted it to work. But reality hit—these tools still struggle once the problem goes beyond boilerplate.

Leaderboards and benchmarks may look impressive, but they don’t capture what happens when you try to build real applications. In practice, copilots:

-> Shine at small, repetitive tasks.
-> Struggle with abstraction, system integration, and real-world constraints.
-> Often add more debugging than acceleration.

Unless you’ve been through the full cycle of designing, coding, and deploying with these tools, you won’t see the gap between demo performance and production reality.

I’m preparing a detailed breakdown from the app I’ve built—and will share soon. This will help manage expectations and shape how we think about building with these tools.

🤖💳 What if your AI agent could walk into the marketplace, bargain like a pro, and pay instantly on your behalf—all while following the exact rules you set?

That’s the future Agentic Commerce promises, and Google’s newly announced Agent Payments Protocol (AP2) is the scaffolding to make it real.

🔑 Why AP2 matters
-> Mandates with intent → Digitally signed instructions ensure agents act only within your authorization.
-> Payment flexibility → From credit cards to bank transfers to stablecoins (via the x402 crypto extension).
-> Delegated autonomy → Agents can act later (e.g., buy below a price threshold) without constant oversight.
-> Accountability by design → Every transaction leaves a verifiable, auditable trail.

🌍 The bigger picture
-> Trust unlocks adoption: AP2 addresses the #1 blocker — fear of losing control over payments.
-> New models emerge: Autonomous travel booking, dynamic deal-hunting, subscription management.
-> Interoperability at scale: Backed by 60+ partners across payments, fintech, merchants, and crypto.

⚠️ What to watch
-> Regulatory alignment across geographies.
-> User clarity in understanding what exactly they are authorizing.
-> Merchant adoption costs and readiness for crypto/stablecoin rails.

💡 My take: This isn’t just about payments. It’s about building the trust framework for agentic ecosystems, where AI doesn’t just answer queries but executes real-world transactions safely and transparently.

Read more @ https://lnkd.in/dXxRzU8S

#AP2 #google #agents Google

🤖 AI Copilots: 10 Realities of AI Copilots You Should Know

AI copilots are changing the way we work — coding faster, drafting smarter, analyzing quicker.

But like every breakthrough, they come with important realities to manage.
Here are the Top 10 truths about AI copilots that matter in practice 👇

1️⃣ Hallucination Happens
Copilots can be confident… but not always correct. The real skill is knowing when to trust, and when to verify.
2️⃣ Context is Everything
The best copilots are only as good as the data you give them. High-quality, secure context = high-quality outcomes.
3️⃣ The Hidden Cost Curve
Each interaction consumes compute. At scale, “small tasks” can quietly grow into big bills.
4️⃣ Impact Beyond the Screen
Every AI response requires energy. As usage rises, organizations are starting to measure and optimize that impact.
5️⃣ Human + AI = Balance
Copilots accelerate work, but human judgment keeps it meaningful. Over-reliance risks eroding critical skills.
6️⃣ A New Security Frontier
From prompt injections to hidden data leaks, copilots introduce new attack surfaces that demand vigilance.
7️⃣ Bias Scales Fast
What’s in the data flows into the decisions. Without guardrails, bias can be amplified in seconds.
8️⃣ Beyond the Chatbox
Real value comes when copilots integrate seamlessly into workflows — not just as a side window.
9️⃣ Governance Matters
Clear ownership, audit trails, and accountability frameworks are still catching up with how copilots are used.
🔟 Expectations Shape Experience
They are powerful assistants, not sources of ultimate truth. Setting the right expectations ensures adoption, not frustration.

AI copilots aren’t just tools — they’re work companions. The leaders who succeed will be those who combine innovation, governance, and human oversight to unlock their full potential.

AI Doesn’t Think — And That’s Why It Fails in Surprising Ways

AI isn’t a brain. It doesn’t “understand” the way we do.
It predicts — the next best word, image, or action — at astonishing speed.

Even the new wave of reasoning models doesn’t change this.
They still predict — only now layering those predictions into step-by-step chains that look like logic.

And this is why AI fails.
AI will fail in unfamiliar territory, when there’s a lack of data, in ambiguity without context, and sometimes even with basic common sense.

Let me share one of my own experiences.
While working on an application, AI generated overly complex code — even though a much simpler alternative existed. It didn’t use the latest APIs either, and even when I pointed it to new documents, it couldn’t infer the better approach.

Why? Because the model had no awareness of simplicity, relevance, or context.

From building many AI apps, I’ve learned that unless you apply your own judgment, the output may look correct but still be far from optimal. That’s where your experience comes in — you may have solved a similar problem in a better way before, or you have the intuition to infer that things could be made simpler. The judgment and real thinking can’t be replaced, and that’s exactly the paradox of AI: brilliant when patterns are rich, brittle when patterns are thin.

But here’s the key: if you understand this, you can leverage it.
-> Use AI where patterns and data are strong.
-> Feed the patterns you observe, fine-tune where needed, and apply human judgment to bridge the gaps.
-> That’s how prediction becomes power.

Next time you’re impressed (or alarmed) by AI, pause and remember:
It’s not magic — it’s prediction, analysis, and processing at a speed no human brain could match.

And that ability to turn raw data into instant output may be the most magical thing of all — especially when paired with human intelligence.

💡 What’s been your biggest AI surprise (good or bad)? 👇

💡 These 10 strategies for Generative AI can help organizations save cost, reduce carbon, and optimize energy use — while ensuring systems scale responsibly and remain regulation-ready.

📄 Download the full document here 👇

🌍 Sustainable AI: 10 Actionable Strategies
AI is advancing at an incredible pace — copilots, agentic workflows, and large-scale deployments are becoming the norm. But as AI adoption accelerates, so does the conversation around responsibility, efficiency, and long-term resilience.

The latest edition of the newsletter dives into 10 actionable strategies for Sustainable AI — a practical playbook for organizations looking to innovate responsibly while staying ahead of the curve.

This isn’t about waiting for regulations. It’s about mindset, competitive advantage, and building AI systems that scale efficiently, responsibly, and sustainably. #sustainableai #greenai #ai Green Software Foundation

📩 Read the full blog in the latest newsletter here 👇

🌍 The Hidden Cost of AI at Scale: It’s Time for a Sustainable AI Playbook

Most reports focus on the cost of a single prompt in terms of energy — but that misses the bigger picture.

The real challenge? Billions of prompts running daily. Multi-agent workflows looping across models. Workloads distributed globally. These small inefficiencies compound into massive energy, carbon, and cost burdens that are reshaping our infrastructure demands.

A Sustainable AI Playbook helps address this by embedding sustainability at every stage of the AI lifecycle:
🔹 Design with Responsibility – Minimize unnecessary complexity, choose the right model size, and optimize code for efficiency.
🔹 Measure What Matters – Apply standards like the upcoming Software Carbon Intensity (SCI) framework for AI to track emissions across training, inference, and operations.
🔹 Carbon-Aware Operations – Run workloads where and when clean energy is available, right-size infrastructure, and optimize scheduling.
🔹 Lean Agentic Workflows – Balance autonomy, collaboration, and tool use while keeping cost, carbon, and complexity under control.
🔹 Governance & Accountability – Establish sustainable AI guidelines for development and deployment, policies, guardrails, and transparent reporting to ensure sustainability goals are consistently met.
🔹 Culture of Green AI – Build awareness, training, and accountability across teams to make sustainability part of everyday AI practices.

💡 Sustainable AI isn’t just about reducing emissions — it’s about making AI efficient, resilient, and responsible at scale, while also lowering operational costs.

#sustainableai #leanagenticai #greenai Green Software Foundation

🚫 Never Start with Code — That’s Not How You Work with AI.
It’s tempting.
You open your favorite AI assistant.
You type: “Build a login page with OTP.
And it delivers. Fast.

But here’s the truth:
👉 Starting with code is the fastest way to build the wrong thing — beautifully.
Because when you lead with code, you:
🔹 Get locked into the first idea, not the best one
🔹 Accept hallucinations: fake APIs, unstable logic, random packages
🔹 Ignore trade-offs: security, performance, energy, and maintenance
🔹 Create complexity that’s hard to unwind

🧠 We need to move from Copilot to CoThinker
AI shouldn’t just generate code.
It should help you reason.

Before you even ask for code, ask:
💬 What’s the problem I’m solving?
🧠 What are 2–3 ways to solve it?
⚖️ What matters most — performance, security, or sustainability?
🧰 What’s the right language, package, or design for this context?
Only then should the AI assist you — not replace your thinking.
✅ CoThinking in Action

Here’s a better workflow:
🔍 Define intent — not just instructions
🧱 Break down architecture before code
⚡ Model trade-offs (speed, energy, complexity, emissions)
🔐 Prioritize security, reliability, and sustainability
✍️ Let AI code — but you stay in control

💡 Code is easy part. Clarity is rare.
The future of software is not Copilot.
It’s CoThinker.
Not just typing faster — thinking better.

Sam Altman recently shared that some people are now using ChatGPT like therapy or life coaching. While he welcomed this exploration, he also warned about a small group of users who struggle to separate fiction from reality. The message is clear: AI should support mental well-being—not replace human connection or reinforce delusions.

🔹 Two years ago, I explored this concept in my book “The AI Life Coach: Personal Growth and Transformation with the Power of Generative AI”. The core idea remains deeply relevant today.

Life is a series of questions.
From the moment we wake to the time we rest, our minds ask—How do I grow? Lead better? Respond with empathy? We’ve always leaned on mentors, books, conversations, and experiences to guide us.

Now, AI offers something new: a thinking partner—available anytime, equipped with the world’s knowledge, offering guidance in seconds. But here’s the key:
AI can help you think better—not think for you.
Human wisdom stays the anchor; AI is the amplifier.

📖 Through practical scenarios and real-life examples, I explore how you can use AI to:

• Reflect on your decisions
• Improve emotional awareness
• Ask better questions
• Strengthen leadership habits
• Make value-aligned choices

🔸 But how you use it matters:
✨ Set clear intent when seeking answers
✨ Interpret responses with curiosity, not blind faith
✨ Take action based on your values, not just AI suggestions
✨ Seek real-world feedback and human counsel
✨ Protect your emotional space—AI isn’t a therapist

Used well, AI becomes a companion for personal growth. Misused, it can blur boundaries and disempower judgment. The balance lies in awareness and intentional use.

👉 Get your copy of AI Life coach at Amazon : https://lnkd.in/dnnKxx2h

⚠️ While LLM providers keep increasing context window sizes, designing for long context windows isn’t the right approach.

Here’s why:
🔹 Inefficiency at Scale
Bigger windows mean more tokens per request. That adds overhead without delivering proportional gains in reasoning or outcomes.
🔹 Noise Over Signal
Feeding everything into the model doesn’t ensure better answers. Longer contexts can blur what’s truly relevant, leading to weaker responses.
🔹 Memory Management & Loss of Context
Models still struggle with remembering and prioritizing information over long spans. Extending the window doesn’t solve the deeper challenge of structured memory.
🔹 Smarter Patterns Exist
Techniques like retrieval-augmented generation (RAG), summarization, structured memory, and lean agentic workflows provide sharper, more reliable results.

💡 The principle is simple: design for the right context, not the longest one.
Every unnecessary token adds cost, compute, and carbon overhead.

👉 One practical advice: always design systems with constraints in mind — that’s where true efficiency emerges. For context windows, think: how would you solve the problem if you only had a smaller window available? That mindset pushes you toward leaner, more efficient solutions. #leanagenticai

GPT-5 is teaching us patience… and maybe even reflection.

I’ve been using GPT right from the early days, but their latest thinking model got me thinking.

How do I describe GPT-5?
It doesn’t rush to fill silence. It doesn’t leap to the first answer. Instead, it pauses. It lingers. What could have been spoken in five seconds, it stretches into thirty—not from hesitation, but from reverence for reflection.

And in that pause lies something new: it gives humans the opportunity to think the answer along with it. That’s what makes GPT-5 feel less like a tool, and more like an AI companion—inviting us to share the process rather than just consume the result.

Some might call it slow. I’d call it mindful. While earlier models sprinted, GPT-5 strolls. And in that stroll, it reminds us that not every answer needs to arrive instantly—sometimes, wisdom prefers to be fashionably late.

Don’t take this seriously 🙂
The future version will hopefully be fast—you would have waited long enough.

The true test of Agentic AI isn’t how much it can do — it’s how efficiently, responsibly, and sustainably it can do it.

🎙️ Tune in to my latest episode of Agentic AI: The Future of Intelligent Systems — “Designing Lean Agentic AI: Principles for Sustainable Autonomy.

In just 6 minutes, this episode explores how to design energy-efficient agentic AI systems that deliver results while minimizing cost, carbon, and complexity:

1. Goal Clarity & Planning Depth — the foundation of purposeful autonomy.
   Purposeful Tooling & Models — select the right tools and model tiers; route to smaller models when possible.
2. Efficient Reasoning — manage reflection depth, control reasoning loops, and cut unnecessary tool calls.
3. Retry Strategies — resilience with capped retries and smart backoff instead of wasteful repetition.
4. Memory & Learning — scoped, purposeful memory that supports intelligence without excess overhead.
5. Supporting Resource — free white paper for a deeper dive.

If you’re building AI for impact, this episode shows why lean design is the real path to cost-effective, energy efficient and sustainable autonomy.

▶ Listen here: https://lnkd.in/dAcBrDY7

💡 This is part of a growing series—now over 50+ episodes—on how to design agentic AI systems that are efficient, responsible, and future-ready. If you’re new, you can always catch up with the earlier episodes to dive deeper into the journey.

👉 Follow the podcast for more deep dives and practical insights on shaping the future of intelligent systems.

Google’s latest paper on measuring the environmental impact of AI at scale is an important step forward. It’s the first time we’re seeing production-grade reporting of Gemini Apps serving metrics—and credit to Google for bringing this transparency to the industry.

The numbers stand out:
0.24 Wh of energy per prompt
0.03 g CO₂e per prompt
0.26 mL of water (about five drops)

On their own, these impacts seem tiny. But scale changes everything. If AI prompts begin to replace traditional search queries, we’re looking at at least 1 billion prompts per day. That translates to 240 MWh of energy, 30 tons of CO₂, and 260,000 liters of water daily. At full search scale (~14 billion queries daily), the footprint becomes grid-level and industrial in magnitude.

And that’s just for text prompts. As usage shifts toward multimodal prompts—text-to-image, text-to-video, and more—the per-request footprint will be significantly higher. Add in Agentic AI workflows, where multiple models, tools, retrieval calls, and reasoning loops are orchestrated for a single outcome, and the cumulative impact grows even further.

While the report focused on text prompts, it showed a 33× reduction in energy and a 44× reduction in emissions over one year—a reminder of how important continued efficiency gains will be as AI expands into more resource-intensive multimodal and agentic use cases.

Check out the technical paper here: https://lnkd.in/djFw265T

One point to note: the report presents market-based emissions, which credit clean energy procurement. It would be equally valuable to see location-based emissions, reflecting the actual grid mix where workloads run.

Google’s broader Carbon Footprint tools already show both market-based and location-based emissions side by side. Extending that same dual reporting to AI serving would provide even more clarity and comparability for the ecosystem.

While providers will continue to improve efficiency at the infrastructure and software/model level, it is equally important to design applications in a lean way—minimizing cost, carbon, and complexity, improving energy efficiency, and playing our part. That’s the mindset I explore in detail in my book: leanagenticai.com

#google Green Software Foundation #sustainability

Faster. Leaner. Cost-Effective. Cleaner.

That’s what I’m seeing while experimenting with Rust on Google Cloud Run — now officially supported.
The early results:
✅ Cold starts are fast
✅ Memory usage stays low
✅ CPU time is efficient
✅ Container sizes are small

Since Cloud Run bills by CPU, memory, and execution time, these improvements directly reduce cost per request.

But there’s more.

Less compute used also means less energy consumed.
At scale, this translates to meaningful reductions in both cloud cost and carbon impact.

If you’re running high-throughput services or latency-sensitive APIs, this combination of performance and sustainability is worth looking into.

As the Rust cloud ecosystem matures and more libraries become available, adoption will only grow.

And remember—you don’t need to rewrite everything in Rust.
Start small. Introduce Rust where it brings measurable impact.