As usual, the annual Google DevFest was for me a nice burst of creative energy, technical inspiration, and a fantastic chance to reconnect with old friends, former colleagues, and the local developer community. DevFest is essentially the only local conference with highly relevant, deep-dive content tailored directly to our ecosystem so I rarely miss it.

Here are my top takeaways from DevFest 2026.

The Agentic Software Factory & Shifting Role of the Engineer

The most compelling talk of the day framed modern software delivery as an Agentic Factory—where every part of the system is named, composed, and load-bearing, just like modern manufacturing. This approach aligns particularly well with the work my team is currently doing around building a shared repository of skills, MCP integration, agents, and explicit workflows.

Self-Continuous vs. AI-Assisted

The speaker demonstrated how we are moving from AI-Assisted workflows (where humans drive every step slightly faster) to Self-Continuous agentic engineering. In a self-continuous model, the underlying system carries the heavy lifting through Build, Release, and Operate, while human engineers operate at the governance level—setting intent, defining constraints, and signing off on outcomes.

Scripting Agent Workflows & Standards

A critical takeaway was that AI agents shouldn’t be left to run on unscripted, unpredictable paths. Instead, engineering teams must build explicit, versioned workflows—using defined building blocks like branching logic and gated loops—to control what agents are permitted to do.

Under this approach:

• Toolkits as Artifacts: Agent capabilities, playbooks, and instructions are treated like code—versioned, tested, and discoverable.
• Explicit Standards over Tribal Knowledge: Agents can’t read between the lines or rely on unwritten team habits. Architecture guidelines, design patterns, and evaluation rules must be explicitly written down and published so agents can follow them.

How the Developer Role is Changing

For engineers, the core output is shifting. We are moving away from writing 100% of customer-facing feature code manually. Instead, the modern software engineer’s primary job is building the internal infrastructure, toolkits, evaluation metrics, and guardrails that agents operate within. Agents will increasingly construct the product; engineers will build and govern the factory.

Native is the New Cross-Platform

Another key takeaway was how AI tooling is eroding the traditional value proposition of cross-platform UI frameworks. Because AI-assisted development makes translating business logic and UI patterns across Jetpack Compose and SwiftUI significantly faster, the performance and abstraction trade-offs of cross-platform frameworks are no longer worth the small savings in effort.

It was great to hear the speaker advocate for the exact pattern I’ve been using on Benchmate—KMP Data Layer + Native UI:

• AI-Accelerated Native UI: With AI assisting across Jetpack Compose and SwiftUI, maintaining two true native frontends is no longer the resource bottleneck it used to be.
• Shared Business Core: Core logic, networking, and state management are unified via Kotlin Multiplatform (KMP), leaving native rendering and OS interactions untouched.

Hearing this session reinforced that using KMP to share core logic while keeping true native frontends gives you shared engine efficiency without sacrificing UI performance, animation smoothness, or platform-specific UX.

Cloud-Based Agent Workloads in GCP

Running heavy, multi-step agents on local developer hardware quickly runs into constraints around battery, compute power, and context limits. A key highlight from the Google Cloud sessions was offloading long-running agent workloads directly into managed cloud environments.

• Cloud Workstations for Agents: Developers can run stateful, long-running agent tasks in GCP Cloud Workstations—using automated background heartbeats to prevent idle timeouts while preserving RAM, background processes, and active agent context.
• Developer Knowledge MCP & Skills: To prevent model hallucination and context bloat, documentation tools (like Developer Knowledge MCP) use progressive disclosure—loading full documentation and API specifications only when the specific task demands it.
• Managed Agents Platform: The speaker showcased managed agent runtimes (such as AlphaEvolve, Deep Research, and the Managed Agents API) designed to handle background analysis and automated optimization server-side.

Other Highlights

Beyond the sessions mentioned above, several talks provided excellent insights worth incorporating into our roles:

Leadership & Job Crafting

A great session on moving from individual contributor to engineering leader introduced Job Crafting. Fulfillment and impact come from actively crafting your role across three dimensions:

1. Task Crafting: Changing how you perform tasks (e.g., explaining why in code reviews rather than just stamping approval).
2. Relational Crafting: Shifting interactions (e.g., pairing with junior engineers).
3. Cognitive Crafting: Reframing the job’s purpose (e.g., viewing code reviews and system design as core multiplicative work, not time away from “real” coding).

Practical AI Governance

Governance doesn’t have to mean bureaucratic slowdown. Effective AI governance relies on simple, explicit engineering controls:

• AI Register: Every AI agent, tool, or feature must have a named owner and a risk rating. If it isn’t in the register, it isn’t governed.
• The Vendor Evidence Rule: “No official documentation = no finding”. Security and compliance assessments must cite official vendor documentation, DPAs, or model cards.

Server-Driven UI & Dynamic GenUI

Server-Driven UI (SDUI) was historically discouraged due to client-side complexity and rigidity. However, in the age of generative AI, teams are reconsidering it. Using protocols like Google’s A2UI (Agent-to-User Interface), server-driven rendering allows agents to dynamically construct hyper-personalized, context-aware UI components on the fly.

Static Guardrails with Custom Lint Rules

To avoid the “slop doom loop” of unvetted AI-generated code, teams are leveraging the Kotlin Analysis API to build custom static lint rules. Enforcing automated style, security, and architectural guardrails at the compiler level ensures both human and agent code adhere to codebase standards.

Jetpack Compose Performance Wins

On the pure Android performance front, a standout session focused on frame-rate optimization in Jetpack Compose:

• draw Modifiers over Recomposition: Optimizing Compose rendering by deferring layout and composition passes—leveraging custom drawWithContent or drawBehind modifiers to avoid unnecessary layout re-calculations during animations.
• Compose Stability Analyser: Using tools like the Compose Stability Analyser Android Studio plugin to catch unstable parameters and classes that trigger unnecessary recompositions and degrade UI performance.

Conclusion

DevFest was a fantastic opportunity to validate that our work in agentic and harness engineering aligns with where the broader Android community is heading. Well done to all the organisers, and the new venue was definitely a winner for me: more room and seats, a much clearer view of the presentations, and great food!