Software Engineering Dec 3 2025 • 4 min read

Agents in Action: Where Software Orchestrates Itself—But Not Without a Fight

The latest crop of software engineering posts tells a story familiar to anyone who's watched modern engineering: scaling is relentless, AI is omnipresent, and infrastructure, despite grand claims, remains stubbornly complicated. The pieces examined here—from AWS's re:Invent keynote drops to Okta's Kubernetes odyssey—show a software world obsessed with evolving automation, untangling complex systems, and reimagining (yet again) how engineers interact with their tools and with knowledge itself.

Agents, Agents Everywhere (with Opinions to Spare)

The AWS re:Invent 2025 highlights make it clear: we are living in the age of the agent. Amazon’s slew of announcements—Nova Forge for custom model building, Nova Act for browser automation, and a DevOps Agent to root out operational problems—spotlight a shift toward specialized, semi-autonomous tools. These agents promise to not just automate, but contextualize and coordinate. Not to be outdone, Atlassian’s Rovo (now supercharged by Unito connectors) is similarly all about AI-powered agents acting across silos, using integrations to gain real organizational context.

However, as always, there’s a catch: integrating these agents across tangled environments and supporting real workflows is still a quagmire. AWS and Atlassian both push for unified graphs and agent-composed ecosystems, but the details reveal persistent friction—connecting tools, mapping data, managing customizations. The pitch is always seamless orchestration; the reality is endless integration work.

Dealing with Non-Determinism: Evals, Not Vibes

AI’s growing reach comes with new headaches. The Pragmatic Engineer’s deep dive into LLM evals exposes how shaky “vibe checks” have been in AI development—shipping changes because they “looked good” on a few samples. Instead, systematic error analysis and clear, domain-specific evaluation (including binary pass/fail judgments, not fuzzy Likert scales) are now essential, especially as LLM workflows get embedded into critical systems.

Code-based tests are great for deterministic outputs, but for subjective outcomes, we now need “LLM-as-judge” systems, meticulous dataset curation, and ongoing human review. The article’s flywheel—measure, analyze, improve, repeat—is becoming the new norm, reminiscent of test-driven strategies in traditional software but with a big upgrade to handle subjective and context-dependent AI behavior.

Scaling Infrastructure: GitOps Grit and the Argo CD Adventure

Okta’s saga of scaling from a dozen to over a thousand Kubernetes clusters—using Argo CD as the backbone—reads like a masterclass in “community-driven pain avoidance.” Git is enforced as the single source of truth, providing strong benefits against config drift and misadventure. Yet nothing about this transition is easy: custom tooling proliferates, automation must be rewritten to accommodate nuances of Terraform and client-specific needs, and performance bottlenecks in open-source projects surface relentlessly at scale.

The broader lesson here: despite all the advances in orchestration and declarative infrastructure, unique organizational requirements still force teams into bespoke solutions. The promise of “just use platform X and it scales automatically” remains a distant dream. As ever, automation amplifies complexity as much as it tames it.

Knowledge Work Gets a New Interface (Again)

Stack Overflow’s AI Assist is another signpost for how developer knowledge workflows are evolving. Gone are the days of pure Q&A and endless tabbing; now, conversational AI surfaces expert answers, augments them contextually, and, crucially, cites sources. There’s a notable shift toward integrating trusted human knowledge with generative AI, acknowledging that pure LLM output is not enough for a skeptical and accuracy-focused development community.

The recurring refrain from Stack’s product team—attribution is non-negotiable, trust is precious—speaks to a world where AI hallucination is an ever-present risk. The new status symbol? Not just a snappy answer, but a fully cited, audit-friendly response chain.

APIs and Ergonomics: Java’s Lazy Constants

In a break from the AI rush, Java’s JEP 526 has landed, offering developers “lazy constants” for deferred, thread-safe computation. It’s an example of classic language evolution: replacing baroque double-checked locking patterns and homegrown init tricks with ergonomic, explicit APIs. The focus here is both on performance (faster startup, no wasted object graphs) and correctness (immutability by default, no more nullable footguns). This sort of incremental upgrade, while less headline-grabbing than the latest AI marvel, is the quiet backbone of long-term software sanity.

The Realities Behind Grand Claims

Pull all this together and a pattern emerges: Software engineering in late 2025 is shaped less by radical reinvention and more by incremental tooling, ongoing integration headaches, and a growing hunger for both automation and auditability. Agents and AI assistants are everywhere, but their boundaries must be carefully constructed and evaluated. Declarative infrastructure helps, but still demands painful custom orchestration at true scale.

In short: we’re not automating away the hard parts—we’re simply shifting them deeper into the stack. And despite all the futuristic marketing, the humans (and their judgment) are not out of a job yet.